User documentation

test_type t

Definition: main.c:6

Here is the caller graph for this function:

◆ getInvertedObjOwnershipParent()

template<class ParentT , class T >

RCP<ParentT> Teuchos::getInvertedObjOwnershipParent ( const RCP< T > & invertedChild )

Get the parent back from an inverted ownership RCP.

Retrieves the RCP<ParentT> object set through rcpWithInvertedObjOwnership().

Here is the caller graph for this function:

◆ getParametersFromYamlFile()

Teuchos::RCP< Teuchos::ParameterList > Teuchos::getParametersFromYamlFile ( const std::string & yamlFileName )

 {
   return YAMLParameterList::parseYamlFile(yamlFileName);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getRawPtr()

template<class Container >

RawPointerConversionTraits<Container>::Ptr_t Teuchos::getRawPtr ( const Container & c )

Definition at line 57 of file Teuchos_getRawPtr.hpp.

 {
   return RawPointerConversionTraits<Container>::getRawPtr(c);
 }

Here is the caller graph for this function:

◆ getSimpleTestTwoDArray()

TwoDArray<int> Teuchos::getSimpleTestTwoDArray ( )

Definition at line 49 of file TwoDArray_UnitTests.cpp.

                                        {
   TwoDArray<int> simpleArray(2,2);
   simpleArray(0,0) =1;
   simpleArray(0,1) =2;
   simpleArray(1,0) =3;
   simpleArray(1,1) =4;
   return simpleArray;
 }

Here is the caller graph for this function:

◆ getStringToIntegralParameterEntryValidator()

template<class IntegralType >

RCP<const StringToIntegralParameterEntryValidator<IntegralType> > Teuchos::getStringToIntegralParameterEntryValidator	(	ParameterEntry const &	entry,
		ParameterList const &	paramList,
		std::string const &	paramName
	)

Get a StringToIntegralParameterEntryValidator<IntegralType> object out of a ParameterEntry object.

This function with thrown of the validator does not exist.

Here is the caller graph for this function:

◆ getUnitTestName()

std::string Teuchos::getUnitTestName	(	const std::string	groupName,
		const std::string	testName
	)

Definition at line 101 of file Teuchos_UnitTestRepository.cpp.

 {
   std::ostringstream oss;
   oss << groupName<<"_"<<testName<<"_UnitTest";
   return oss.str();
 }

◆ getYamlArray()

template<typename T >

Teuchos::Array<T> Teuchos::getYamlArray ( const YAML::Node & node )

Definition at line 56 of file Teuchos_YamlParser.cpp.

 {
   Teuchos::Array<T> arr;
   for(YAML::const_iterator it = node.begin(); it != node.end(); it++)
   {
     arr.push_back(it->as<T>());
   }
   return arr;
 }

Here is the call graph for this function:

◆ globalReduceSuccess()

void Teuchos::globalReduceSuccess	(	bool &	success,
		FancyOStream &	out
	)

Definition at line 71 of file GlobalMPISession_UnitTests.cpp.

 {
 #ifdef HAVE_MPI
   int globalSumSuccessInt = -1;
   int localSuccessInt = (success ? 0 : 1);
   MPI_Allreduce(&localSuccessInt, &globalSumSuccessInt, 1,
     MPI_INT, MPI_SUM, MPI_COMM_WORLD);
   TEST_EQUALITY_CONST(globalSumSuccessInt, 0);
 #endif
 }

Here is the caller graph for this function:

◆ haveSameValuesUnordered()

bool Teuchos::haveSameValuesUnordered	(	const Teuchos::ParameterList &	lhs,
		const Teuchos::ParameterList &	rhs,
		bool	verbose
	)

Definition at line 140 of file Teuchos_YamlParser.cpp.

 {
   typedef Teuchos::ParameterList::ConstIterator Iter;
   Iter i = lhs.begin();
   Iter j = rhs.begin();
   if(lhs.name() != rhs.name())
   {
     if(verbose)
     {
       std::cout << "Parameter list names: \"" << lhs.name() << "\" and \"" << rhs.name() << "\".\n";
     }
     return false;
   }
   for(; i != lhs.end(); i++)
   {
     const std::string& key = lhs.name(i);
     const Teuchos::ParameterEntry& val1 = lhs.entry(i);
     //check that rhs also contains this key
     if(!rhs.isParameter(key))
     {
       if(verbose)
       {
         std::cout << "One list is missing parameter: \"" << key << "\"\n";
       }
       return false;
     }
     const Teuchos::ParameterEntry& val2 = rhs.getEntry(key);
     const Teuchos::any& any1 = val1.getAny(false);
     const Teuchos::any& any2 = val2.getAny(false);
     //check that types match
     if(any1.type() != any2.type())
     {
       if(verbose)
       {
         std::cout << "Values for key \"" << key << "\" have different types.\n";
       }
       return false;
     }
     //check for parameter list special case (don't use operator==)
     if(any1.type() == typeid(Teuchos::ParameterList))
     {
       if(!haveSameValuesUnordered(Teuchos::any_cast<Teuchos::ParameterList>(any1), Teuchos::any_cast<Teuchos::ParameterList>(any2), verbose))
       {
         //Don't need to print message here, the deepest list not matching will do that
         return false;
       }
     }
     else
     {
       //otherwise, use == to compare the values
       if(!(val1 == val2))
       {
         if(verbose)
         {
           std::cout << "Values for key \"" << key << "\" are different.\n";
         }
         return false;
       }
     }
     j++;
   }
   //lists must have same # of entries
   if(j != rhs.end())
   {
     if(verbose)
     {
       std::cout << "Lists \"" << lhs.name() << "\" and \"" << rhs.name() << "\" have different number of parameters.\n";
     }
     return false;
   }
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ implicit_cast()

template<class TypeTo , class TypeFrom >

TypeTo Teuchos::implicit_cast ( const TypeFrom & t )

inline

Perform an implicit cast of concrete types with the casted object returned by value.

This function is used as:

TypeTo myCast( const TypeFrom& a )
{
  return Teuchos::implicit_cast<TypeTo>(a);
}

This function will only compile for types where an implicit conversion from objects of type TypeFrom to type TypeTo exists. Note that this is a weaker operation than a static_cast<TypeTo>(t) in that the static cast will actually compile in cases where the implicit conversion would not compile and may result in incorrect code. This function can not result in incorrect code, assuming that the implicit conversions themselves do no result in incorrect code (which is another matter all together).

This function is especially helpful when one needs to be careful of what specific type is passed in as a formal argument to a function and in comparing values. In particular, using this function is far safer than using TypeTo(t) in cases where TypeTo is a built in type since TypeTo(t) in these cases is equivalent to (TypeTo)t which is an unchecked sledge-hammer cast of the worst kind.

Definition at line 81 of file Teuchos_implicit_cast.hpp.

81 { return t; }

test_type t

Definition: main.c:6

Here is the caller graph for this function:

◆ implicit_ptr_cast()

template<class TypeTo , class TypeFrom >

TypeTo* Teuchos::implicit_ptr_cast ( TypeFrom * t )

inline

Perform an implicit cast of pointer types with a pointer being returned.

This function is used as:

TypeTo* myPtrCast( TypeFrom *ptr1 )
{
  return Teuchos::implicit_ptr_cast<TypeTo>(ptr1);
}

This function will only compile for types where an implicit conversion from pointers of type TypeFrom* to pointers of type TypeTo* exists. It is allowed for the type TypeFrom and TypeTo to actually be const types. For example, we can have TypeFrom = const std::iostream and TypeTo = const std::ostream and Teuchos::implicit_ptr_cast<const std::ostream>(&Teuchos::getConst(std::cout)) would compile just fine.

Note that this is a weaker operation than a static_cast<TypeTo*>(t) in that the static cast will actually compile in cases where the implicit conversion would not compile and may result in incorrect code. For example, a static cast up from a base class to a derived class will compile (and may be wrong) while this implicit cast function will not compile for such casts. This function can not result in incorrect code, assuming that the implicit conversions themselves do no result in incorrect code (which is another matter all together).

Definition at line 150 of file Teuchos_implicit_cast.hpp.

150 { return t; }

test_type t

Definition: main.c:6

◆ implicit_ref_cast()

template<class TypeTo , class TypeFrom >

TypeTo& Teuchos::implicit_ref_cast ( TypeFrom & t )

inline

Perform an implicit cast of reference types with a reference being returned.

This function is used as:

TypeTo& myPtrCast( TypeFrom &ref1 )
{
  return Teuchos::implicit_ref_cast<TypeTo>(ref1);
}

This function will only compile for types where an implicit conversion from references of type TypeFrom& to references of TypeTo& exists. It is allowed for the type TypeFrom and TypeTo to actually be const types. For example, we can have TypeFrom = const std::iostream and TypeTo = const std::ostream and Teuchos::implicit_ref_cast<const std::ostream>(Teuchos::getConst(std::cout)) would compile just fine.

Note that this is a weaker operation than a static_cast<TypeTo&>(t) in that the static cast will actually compile in cases where the implicit conversion would not compile and may result in incorrect code. For example, a static cast from a base to a derived class will compile (and may be wrong) while this implicit cast function will not compile for casts from base to derived classes. This function can not result in incorrect code, assuming that the implicit conversions themselves do no result in incorrect code (which is another matter all together).

Definition at line 116 of file Teuchos_implicit_cast.hpp.

116 { return t; }

test_type t

Definition: main.c:6

◆ includesVerbLevel()

bool Teuchos::includesVerbLevel	(	const EVerbosityLevel	verbLevel,
		const EVerbosityLevel	requestedVerbLevel,
		const bool	isDefaultLevel = `false`
	)

Return a std::string representation of the verbosity level.

Needed for serialization KLN 23/09/2010Return true if the verbosity level includes the given level.

Parameters

verbLevel	[in] The verbosity level that is in effect.
requestedVerbLevel	[in] The verbosity level the client is asking if is included in `verbLevel`.
isDefaultLevel	[in] Set to `true` if the level in `requestedVerbLevel` is the default verbosity level. In this case, if `verbLevel==VERB_DEFAULT`, then this function will return `true`. The default value is `false`.

Definition at line 101 of file Teuchos_VerbosityLevel.cpp.

 {
   return (
     ( as<int>(verbLevel) >= as<int>(requestedVerbLevel) )
     ||
     ( verbLevel == VERB_DEFAULT && isDefaultLevel )
     );
 }

Here is the caller graph for this function:

◆ incrVerbLevel()

Teuchos::EVerbosityLevel Teuchos::incrVerbLevel	(	const EVerbosityLevel	inputVerbLevel,
		const int	numLevels
	)

Return an increased or decreased verbosity level.

Parameters

inputVerbLevel	[in] The base verbosity level.
numLevels	[in] The number of levels to increase (>0) or decrease (<0).

See the function implementation for details on what it does!

Definition at line 116 of file Teuchos_VerbosityLevel.cpp.

 {
   if (inputVerbLevel == VERB_DEFAULT)
     return VERB_DEFAULT;
   if (inputVerbLevel == VERB_EXTREME)
     return VERB_EXTREME;
   const int intVerbLevel = as<int>(inputVerbLevel) + numLevels;
   if (intVerbLevel < as<int>(VERB_NONE))
     return VERB_NONE;
   else if (intVerbLevel > as<int>(VERB_EXTREME))
     return VERB_EXTREME;
   // If we get here, then intVerbLevel is a valid verbosity level.
   return verbLevelArray[intVerbLevel];
 }

◆ insert() [1/3]

dependentList Teuchos::insert ( myDepList. getEntryRCPdependent2 )

Here is the caller graph for this function:

◆ insert() [2/3]

dependentList Teuchos::insert ( myDepList. getEntryRCPdependent3 )

◆ insert() [3/3]

dependentList Teuchos::insert ( myDepList. getEntryRCPdependent1 )

◆ ireceive() [1/2]

template<typename Ordinal , class ViewType >

std::enable_if<(Kokkos::Impl::is_view<ViewType>::value),RCP<CommRequest<Ordinal> > >::type Teuchos::ireceive	(	const ViewType &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< Ordinal > &	comm
	)

Variant of ireceive that takes a tag argument (and restores the correct order of arguments).

Definition at line 113 of file Kokkos_TeuchosCommAdapters.hpp.

 {
   using Kokkos::Compat::persistingView;
   return ireceive(persistingView(recvBuffer), sourceRank, tag, comm);
 }

Here is the call graph for this function:

◆ ireceive() [2/2]

template<typename Ordinal , typename Packet >

RCP<CommRequest<Ordinal> > Teuchos::ireceive	(	const ArrayRCP< Packet > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< Ordinal > &	comm
	)

Variant of ireceive that takes a tag argument (and restores the correct order of arguments).

Here is the caller graph for this function:

◆ ireceive< int, double >() [1/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, double >	(	const Comm< int > &	comm,
		const ArrayRCP< double > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 976 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, double>");
   return ireceiveImpl<double> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, double >() [2/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, double >	(	const ArrayRCP< double > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 986 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, double>");
   return ireceiveImpl<double> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, double >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, double >	(	const Comm< int > &	comm,
		const ArrayRCP< double > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 976 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, double>");
   return ireceiveImpl<double> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, double >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, double >	(	const ArrayRCP< double > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 986 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, double>");
   return ireceiveImpl<double> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, float >() [1/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, float >	(	const Comm< int > &	comm,
		const ArrayRCP< float > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1044 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, float>");
   return ireceiveImpl<float> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, float >() [2/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, float >	(	const ArrayRCP< float > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1054 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, float>");
   return ireceiveImpl<float> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, float >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, float >	(	const Comm< int > &	comm,
		const ArrayRCP< float > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1044 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, float>");
   return ireceiveImpl<float> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, float >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, float >	(	const ArrayRCP< float > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1054 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, float>");
   return ireceiveImpl<float> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, int >() [1/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, int >	(	const Comm< int > &	comm,
		const ArrayRCP< int > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1542 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, int>");
   return ireceiveImpl<int> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, int >() [2/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, int >	(	const ArrayRCP< int > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1552 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, int>");
   return ireceiveImpl<int> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, int >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, int >	(	const Comm< int > &	comm,
		const ArrayRCP< int > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1542 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, int>");
   return ireceiveImpl<int> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, int >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, int >	(	const ArrayRCP< int > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1552 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, int>");
   return ireceiveImpl<int> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, long >() [1/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, long >	(	const Comm< int > &	comm,
		const ArrayRCP< long > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1328 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, long>");
   return ireceiveImpl<long> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, long >() [2/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, long >	(	const ArrayRCP< long > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1338 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, long>");
   return ireceiveImpl<long> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, long >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, long >	(	const Comm< int > &	comm,
		const ArrayRCP< long > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1328 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, long>");
   return ireceiveImpl<long> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, long >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, long >	(	const ArrayRCP< long > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1338 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, long>");
   return ireceiveImpl<long> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, long long >() [1/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, long long >	(	const ArrayRCP< long long > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1149 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, long long>");
   return ireceiveImpl<long long> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, long long >() [2/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, long long >	(	const Comm< int > &	comm,
		const ArrayRCP< long long > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1139 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, long long>");
   return ireceiveImpl<long long> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, long long >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, long long >	(	const Comm< int > &	comm,
		const ArrayRCP< long long > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1139 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, long long>");
   return ireceiveImpl<long long> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, long long >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, long long >	(	const ArrayRCP< long long > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1149 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, long long>");
   return ireceiveImpl<long long> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, short >() [1/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, short >	(	const ArrayRCP< short > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1739 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, short>");
   return ireceiveImpl<short> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, short >() [2/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, short >	(	const Comm< int > &	comm,
		const ArrayRCP< short > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1729 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, short>");
   return ireceiveImpl<short> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, short >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, short >	(	const Comm< int > &	comm,
		const ArrayRCP< short > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1729 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, short>");
   return ireceiveImpl<short> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, short >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, short >	(	const ArrayRCP< short > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1739 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, short>");
   return ireceiveImpl<short> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, std::complex< double > >() [1/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, std::complex< double > >	(	const Comm< int > &	comm,
		const ArrayRCP< std::complex< double > > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 837 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, std::complex<double> >");
   return ireceiveImpl<std::complex<double> > (comm, recvBuffer, sourceRank);
 }

◆ ireceive< int, std::complex< double > >() [2/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, std::complex< double > >	(	const ArrayRCP< std::complex< double > > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 847 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, std::complex<double> >");
   return ireceiveImpl<std::complex<double> > (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, std::complex< double > >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, std::complex< double > >	(	const Comm< int > &	comm,
		const ArrayRCP< std::complex< double > > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 837 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, std::complex<double> >");
   return ireceiveImpl<std::complex<double> > (comm, recvBuffer, sourceRank);
 }

◆ ireceive< int, std::complex< double > >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, std::complex< double > >	(	const ArrayRCP< std::complex< double > > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 847 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, std::complex<double> >");
   return ireceiveImpl<std::complex<double> > (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, std::complex< float > >() [1/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, std::complex< float > >	(	const ArrayRCP< std::complex< float > > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 915 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, std::complex<float> >");
   return ireceiveImpl<std::complex<float> > (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, std::complex< float > >() [2/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, std::complex< float > >	(	const Comm< int > &	comm,
		const ArrayRCP< std::complex< float > > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 905 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, std::complex<float> >");
   return ireceiveImpl<std::complex<float> > (comm, recvBuffer, sourceRank);
 }

◆ ireceive< int, std::complex< float > >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, std::complex< float > >	(	const Comm< int > &	comm,
		const ArrayRCP< std::complex< float > > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 905 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, std::complex<float> >");
   return ireceiveImpl<std::complex<float> > (comm, recvBuffer, sourceRank);
 }

◆ ireceive< int, std::complex< float > >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, std::complex< float > >	(	const ArrayRCP< std::complex< float > > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 915 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, std::complex<float> >");
   return ireceiveImpl<std::complex<float> > (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, unsigned int >() [1/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, unsigned int >	(	const Comm< int > &	comm,
		const ArrayRCP< unsigned int > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1635 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, unsigned int>");
   return ireceiveImpl<unsigned int> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, unsigned int >() [2/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, unsigned int >	(	const ArrayRCP< unsigned int > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1645 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, unsigned int>");
   return ireceiveImpl<unsigned int> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, unsigned int >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, unsigned int >	(	const Comm< int > &	comm,
		const ArrayRCP< unsigned int > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1635 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, unsigned int>");
   return ireceiveImpl<unsigned int> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, unsigned int >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, unsigned int >	(	const ArrayRCP< unsigned int > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1645 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, unsigned int>");
   return ireceiveImpl<unsigned int> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, unsigned long >() [1/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, unsigned long >	(	const Comm< int > &	comm,
		const ArrayRCP< unsigned long > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1422 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, unsigned long>");
   return ireceiveImpl<unsigned long> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, unsigned long >() [2/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, unsigned long >	(	const ArrayRCP< unsigned long > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1432 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, unsigned long>");
   return ireceiveImpl<unsigned long> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, unsigned long >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, unsigned long >	(	const Comm< int > &	comm,
		const ArrayRCP< unsigned long > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1422 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, unsigned long>");
   return ireceiveImpl<unsigned long> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, unsigned long >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, unsigned long >	(	const ArrayRCP< unsigned long > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1432 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, unsigned long>");
   return ireceiveImpl<unsigned long> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, unsigned long long >() [1/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, unsigned long long >	(	const Comm< int > &	comm,
		const ArrayRCP< unsigned long long > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1232 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, unsigned long long>");
   return ireceiveImpl<unsigned long long> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, unsigned long long >() [2/4]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::ireceive< int, unsigned long long >	(	const ArrayRCP< unsigned long long > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1242 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, unsigned long long>");
   return ireceiveImpl<unsigned long long> (recvBuffer, sourceRank, tag, comm);
 }

◆ ireceive< int, unsigned long long >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, unsigned long long >	(	const Comm< int > &	comm,
		const ArrayRCP< unsigned long long > &	recvBuffer,
		const int	sourceRank
	)

Definition at line 1232 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, unsigned long long>");
   return ireceiveImpl<unsigned long long> (comm, recvBuffer, sourceRank);
 }

Here is the caller graph for this function:

◆ ireceive< int, unsigned long long >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::ireceive< int, unsigned long long >	(	const ArrayRCP< unsigned long long > &	recvBuffer,
		const int	sourceRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1242 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR("ireceive<int, unsigned long long>");
   return ireceiveImpl<unsigned long long> (recvBuffer, sourceRank, tag, comm);
 }

◆ isend() [1/13]

template<typename Ordinal , class ViewType >

std::enable_if<(Kokkos::Impl::is_view<ViewType>::value),RCP<CommRequest<Ordinal> > >::type Teuchos::isend	(	const ViewType &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< Ordinal > &	comm
	)

Variant of isend() that takes a tag (and restores the correct order of arguments).

Definition at line 101 of file Kokkos_TeuchosCommAdapters.hpp.

 {
   using Kokkos::Compat::persistingView;
   return isend(persistingView(sendBuffer), destRank, tag, comm);
 }

Here is the call graph for this function:

◆ isend() [2/13]

template<typename Ordinal , typename Packet >

RCP<CommRequest<Ordinal> > Teuchos::isend	(	const ArrayRCP< const Packet > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< Ordinal > &	comm
	)

Variant of isend() that takes a tag (and restores the correct order of arguments).

◆ isend() [3/13]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::isend	(	const ArrayRCP< const std::complex< double > > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 879 of file Teuchos_CommHelpers.cpp.

 {
   return isendImpl<std::complex<double> > (sendBuffer, destRank, tag, comm);
 }

Here is the caller graph for this function:

◆ isend() [4/13]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::isend	(	const ArrayRCP< const std::complex< float > > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 947 of file Teuchos_CommHelpers.cpp.

 {
   return isendImpl<std::complex<float> > (sendBuffer, destRank, tag, comm);
 }

◆ isend() [5/13]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::isend	(	const ArrayRCP< const double > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1018 of file Teuchos_CommHelpers.cpp.

 {
   return isendImpl<double> (sendBuffer, destRank, tag, comm);
 }

◆ isend() [6/13]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::isend	(	const ArrayRCP< const float > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1086 of file Teuchos_CommHelpers.cpp.

 {
   return isendImpl<float> (sendBuffer, destRank, tag, comm);
 }

◆ isend() [7/13]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::isend	(	const ArrayRCP< const long long > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1181 of file Teuchos_CommHelpers.cpp.

 {
   return isendImpl<long long> (sendBuffer, destRank, tag, comm);
 }

◆ isend() [8/13]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::isend	(	const ArrayRCP< const unsigned long long > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1274 of file Teuchos_CommHelpers.cpp.

 {
   return isendImpl<unsigned long long> (sendBuffer, destRank, tag, comm);
 }

◆ isend() [9/13]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::isend	(	const ArrayRCP< const long > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1370 of file Teuchos_CommHelpers.cpp.

 {
   return isendImpl<long> (sendBuffer, destRank, tag, comm);
 }

◆ isend() [10/13]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::isend	(	const ArrayRCP< const unsigned long > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1464 of file Teuchos_CommHelpers.cpp.

 {
   return isendImpl<unsigned long> (sendBuffer, destRank, tag, comm);
 }

◆ isend() [11/13]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::isend	(	const ArrayRCP< const int > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1584 of file Teuchos_CommHelpers.cpp.

 {
   return isendImpl<int> (sendBuffer, destRank, tag, comm);
 }

◆ isend() [12/13]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::isend	(	const ArrayRCP< const unsigned int > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1677 of file Teuchos_CommHelpers.cpp.

 {
   return isendImpl<unsigned int> (sendBuffer, destRank, tag, comm);
 }

◆ isend() [13/13]

template<>

RCP<Teuchos::CommRequest<int> > Teuchos::isend	(	const ArrayRCP< const short > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1771 of file Teuchos_CommHelpers.cpp.

 {
   return isendImpl<short> (sendBuffer, destRank, tag, comm);
 }

◆ isend< int, double >()

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::isend< int, double >	(	const ArrayRCP< const double > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Here is the caller graph for this function:

◆ isend< int, float >()

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::isend< int, float >	(	const ArrayRCP< const float > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Here is the caller graph for this function:

◆ isend< int, int >()

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::isend< int, int >	(	const ArrayRCP< const int > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Here is the caller graph for this function:

◆ isend< int, long >()

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::isend< int, long >	(	const ArrayRCP< const long > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Here is the caller graph for this function:

◆ isend< int, long long >()

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::isend< int, long long >	(	const ArrayRCP< const long long > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Here is the caller graph for this function:

◆ isend< int, short >()

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::isend< int, short >	(	const ArrayRCP< const short > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Here is the caller graph for this function:

◆ isend< int, std::complex< double > >()

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::isend< int, std::complex< double > >	(	const ArrayRCP< const std::complex< double > > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

◆ isend< int, std::complex< float > >()

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::isend< int, std::complex< float > >	(	const ArrayRCP< const std::complex< float > > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

◆ isend< int, unsigned int >()

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::isend< int, unsigned int >	(	const ArrayRCP< const unsigned int > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Here is the caller graph for this function:

◆ isend< int, unsigned long >()

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::isend< int, unsigned long >	(	const ArrayRCP< const unsigned long > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Here is the caller graph for this function:

◆ isend< int, unsigned long long >()

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT RCP<CommRequest<int> > Teuchos::isend< int, unsigned long long >	(	const ArrayRCP< const unsigned long long > &	sendBuffer,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Here is the caller graph for this function:

◆ mergeCounterNames()

void Teuchos::mergeCounterNames	(	const Comm< int > &	comm,
		const Array< std::string > &	localNames,
		Array< std::string > &	globalNames,
		const ECounterSetOp	setOp
	)

Merge counter names over all processors.

Different MPI processes may have created different sets of counters. Use this function to reconcile the sets among processes, either by computing their intersection or their union. This is done using a reduction to MPI Rank 0 (relative to the given communicator) and a broadcast to all processes participating in the communicator. We use a reduce-and-broadcast rather than just a reduction, so that all participating processes can use the resulting list of global names as lookup keys for computing global statistics.

Parameters

comm	[in] Communicator over which to merge.
localNames	[in] The calling MPI process' list of (local) counter names.
globalNames	[out] On output, on each MPI process: the results of merging the counter names.
setOp	[in] If Intersection, globalNames on output contains the intersection of all sets of counter names. If Union, globalNames on output contains the union of all sets of counter names.

Definition at line 466 of file Teuchos_PerformanceMonitorBase.cpp.

   {
     const int myRank = comm.getRank();
     const int left = 0;
     const int right = comm.getSize() - 1;
     Array<std::string> theGlobalNames;
     mergeCounterNamesHelper (comm, myRank, left, right,
                              localNames, theGlobalNames, setOp);
 
     // Proc 0 has the list of counter names.  Now broadcast it back to
     // all the procs.
     broadcastStrings (comm, theGlobalNames);
 
     // "Transactional" semantics ensure strong exception safety for
     // output.
     globalNames.swap (theGlobalNames);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mpiCommRequest()

template<class OrdinalType >

RCP<MpiCommRequest<OrdinalType> > Teuchos::mpiCommRequest	(	MPI_Request	rawMpiRequest,
		const ArrayView< char >::size_type	numBytes
	)

inline

Definition at line 355 of file Teuchos_DefaultMpiComm.hpp.

 {
   return rcp (new MpiCommRequest<OrdinalType> (rawMpiRequest, numBytes));
 }

Here is the call graph for this function:

◆ mpiCommStatus()

template<class OrdinalType >

RCP<MpiCommStatus<OrdinalType> > Teuchos::mpiCommStatus ( MPI_Status rawMpiStatus )

inline

Definition at line 166 of file Teuchos_DefaultMpiComm.hpp.

 {
   return rcp (new MpiCommStatus<OrdinalType> (rawMpiStatus));
 }

Here is the call graph for this function:

◆ mpiErrorCodeToString()

std::string Teuchos::mpiErrorCodeToString ( const int errCode )

Human-readable string version of the given MPI error code.

Definition at line 50 of file Teuchos_DefaultMpiComm.cpp.

   {
     if (errCode == MPI_SUCCESS) {
       return "MPI_SUCCESS";
     }
     else {
       char rawErrString[MPI_MAX_ERROR_STRING];
       int len = 0;
       int err = MPI_Error_string (errCode, rawErrString, &len);
       if (err != MPI_SUCCESS) {
         // Assume that the string wasn't written.  This means it might
         // not be null terminated, so make it a valid empty string by
         // writing the null termination character to it.
         if (MPI_MAX_ERROR_STRING > 0) {
           rawErrString[0] = '\0';
         }
       }
       return std::string (rawErrString);
     }
   }

Here is the caller graph for this function:

◆ myDepList()

ParameterList Teuchos::myDepList ( "String Vali Dep List" )

◆ NUMBER_PARAM_TYPE_TEST() [1/2]

Teuchos::NUMBER_PARAM_TYPE_TEST ( int )

◆ NUMBER_PARAM_TYPE_TEST() [2/2]

Teuchos::NUMBER_PARAM_TYPE_TEST ( llint )

◆ NUMBER_VIS_TEST()

Teuchos::NUMBER_VIS_TEST ( int )

Here is the caller graph for this function:

◆ objectBuilder() [1/2]

template<class ObjectType >

RCP<ObjectBuilder<ObjectType> > Teuchos::objectBuilder ( )

Definition at line 184 of file Teuchos_ObjectBuilder.hpp.

 {
   RCP<ObjectBuilder<ObjectType> > ob = rcp(new ObjectBuilder<ObjectType>() );
   return ob;
 }

Here is the call graph for this function:

◆ objectBuilder() [2/2]

template<class ObjectType >

RCP<ObjectBuilder<ObjectType> > Teuchos::objectBuilder	(	const std::string &	objectName,
		const std::string &	objectTypeName
	)

Definition at line 193 of file Teuchos_ObjectBuilder.hpp.

 {
   RCP<ObjectBuilder<ObjectType> > ob = rcp(new ObjectBuilder<ObjectType>() );
   ob->setObjectName(objectName);
   ob->setObjectTypeName(objectTypeName);
   return ob;
 }

Here is the call graph for this function:

◆ operator &&() [1/2]

bool Teuchos::operator&&	(	const dd_real &	a,
		const dd_real &	b
	)

Here is the caller graph for this function:

◆ operator &&() [2/2]

bool Teuchos::operator&&	(	const qd_real &	a,
		const qd_real &	b
	)

Here is the caller graph for this function:

◆ operator<()

bool Teuchos::operator<	(	const UnitTestData &	a,
		const UnitTestData &	b
	)

Definition at line 88 of file Teuchos_UnitTestRepository.cpp.

 {
   if (a.groupName < b.groupName) {
     return true;
   }
   else if (a.groupName > b.groupName) {
     return false;
   }
   return a.insertionIndex < b.insertionIndex;
 }

◆ operator<<() [1/4]

std::ostream& Teuchos::operator<<	(	std::ostream &	os,
		const Teuchos::Object &	obj
	)

 {
   os << obj.label () << std::endl;
   obj.print (os);
   return os;
 }

Here is the call graph for this function:

◆ operator<<() [2/4]

template<class Key >

std::ostream& Teuchos::operator<<	(	std::ostream &	os,
		const HashSet< Key > &	h
	)

     {
       return os << h.toString();
     }

Here is the caller graph for this function:

◆ operator<<() [3/4]

template<class Key , class Value >

std::ostream& Teuchos::operator<<	(	std::ostream &	os,
		const Hashtable< Key, Value > &	h
	)

     {
       return os << toString(h);
     }

Here is the call graph for this function:

◆ operator<<() [4/4]

template<class T >

std::ostream& Teuchos::operator<<	(	std::ostream &	os,
		const TwoDArray< T > &	array
	)

inline

Definition at line 365 of file Teuchos_TwoDArray.hpp.

                                                                  {
   return os << TwoDArray<T>::toString(array);
 }

◆ operator==()

template<typename T >

bool Teuchos::operator==	(	const TwoDArray< T > &	a1,
		const TwoDArray< T > &	a2
	)

Definition at line 418 of file Teuchos_TwoDArray.hpp.

                                                                  {
   if(a1.isSymmetrical() != a2.isSymmetrical()){
     return false;
   }
   if(a1.isSymmetrical()){
     return TwoDDetails::symmetricCompare(a1,a2);
   }
   else{
     return a1.getDataArray() == a2.getDataArray() &&
     a1.getNumRows() == a2.getNumRows() &&
     a1.getNumCols() == a2.getNumCols();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator>>()

template<class T >

std::istringstream& Teuchos::operator>>	(	std::istringstream &	in,
		TwoDArray< T > &	array
	)

Definition at line 356 of file Teuchos_TwoDArray.hpp.

                                                                         {
   array = TwoDArray<T>::fromString(in.str());
   return in;
 }

Here is the call graph for this function:

◆ passfail()

const std::string Teuchos::passfail ( const bool result )

inline

Return "passed" or "failed".

Definition at line 559 of file Teuchos_TestingHelpers.hpp.

 {
   if (!result)
     return "FAILED";
   return "passed";
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ passfail_with_location()

const std::string Teuchos::passfail_with_location	(	const bool	result,
		const std::string &	file,
		const int	lineNumber
	)

Helper function for TEUCHOS_PASS_FAIL(...).

Definition at line 61 of file Teuchos_TestingHelpers.cpp.

 {
   std::string rtn = passfail(result);
   if (!result && showTestFailureLocation()) {
     rtn += " ==> "+file+":"+toString(lineNumber);
   }
   return rtn;
 }

Here is the call graph for this function:

◆ PerfTest_CheckOrAdd_Test()

PerfTestResult Teuchos::PerfTest_CheckOrAdd_Test	(	XMLTestNode	machine_config,
		XMLTestNode	new_test,
		const std::string	filename,
		const std::string	ext_hostname = `std::string()`
	)

Check whether a test is present and match an existing test in an archive.

This function consumes a machine configuration XMLTestNode and a test entry XMLTestNode. It will attempt to read from an existing file containing a test archive, or generate a new one. Optionally a hostname override can be provided, which is for example useful when running on clusters, where the cluster name should be used for the test entries instead of the compute node name. PerfTest_CheckOrAdd_Test will go through the test archive and search for a matching machine name with matching machine configuration and matching test configuration. If one is found the result values will be compared, if not a new test entry is generated and the result written back to the file.

Parameters

machine_config	[in] An XMLTestNode describing the machine configuration.
new_test	[in] An XMLTestNode describing the test.
filename	[in] The name of a file containing a performance test archive.
ext_hostname	[in] An optional hostname to be used instead of the one provided by the OS.

Returns: Whether a matching test is found, or if it was added to an archive.

Here is the list of valid return values:

PerfTestFailed: Matching configuration found, but results are deviating more than the allowed tolerance.
PerfTestPassed: Matching configuration found, and results are within tolerances.
PerfTestNewMachine: The test archive didn't contain an entry with the same machine name. A new entry was generated.
PerfTestNewConfiguration: No matching machine configuration was found. A new entry was generated.
PerfTestNewTest: No matching testname was found. A new entry was generated.
PerfTestNewTestConfiguration: A matching testname was found, but different parameters were used. A new entry was generated.
PerfTestUpdatedTest: A matching test was found but more result values were given then previously found. The entry is updated. This will only happen if all the old result values are present in the new ones, and are within their respective tolerances.

Definition at line 239 of file Teuchos_XMLPerfTestArchive.cpp.

 {
   XMLTestNode database;
   PerfTestResult return_value = PerfTestPassed;
   bool is_new_config = true;
 
   // Open Database File
   //
   // FIXME (mfh 09 Apr 2014) This actually opens the file twice.
   if (std::ifstream (filename.c_str ())) {
     database = FileInputSource (filename).getObject ();
   }
 
   // Get Current Hostname
   char hostname[256];
   memset (hostname, 0, 256);
   if (ext_hostname.empty ()) {
     throw std::runtime_error("Function *gethostname* not supported on Windows.");
   } else {
     strncat (hostname, ext_hostname.c_str (), 255);
   }
 
   XMLTestNode new_test_entry = new_test.getChild ("TestEntry");
 
   if (database.isEmpty ()) {
     database = XMLTestNode ("PerfTests");
   }
   // Does hostname exist?
   if (database.hasChild (hostname)) {
     XMLTestNode machine = database.getChild (hostname);
 
     // Find matching machine configuration
     for (int i = 0; i < machine.numChildren (); ++i) {
       XMLTestNode configuration = machine.getChild (i);
       TEUCHOS_TEST_FOR_EXCEPTION(
         configuration.getTag ().compare ("Configuration") != 0,
         std::runtime_error, "Unexpected Tag \"" << configuration.getTag ()
         << "\"; only children with Tag = \"Configuration\" are allowed in a "
         "MachineEntry.");
 
       TEUCHOS_TEST_FOR_EXCEPTION(
         ! configuration.hasChild ("MachineConfiguration") ||
         ! configuration.hasChild ("Tests"),
         std::runtime_error,
         "A Configuration needs to have a child \"MachineConfiguration\" and a "
         "child \"Tests\".");
 
       XMLTestNode machine_configuration = configuration.getChild ("MachineConfiguration");
       XMLTestNode old_tests = configuration.getChild ("Tests");
 
       if (machine_configuration.hasSameElements (machine_config)) {
         is_new_config = false;
 
         // Find existing test with same tag as the new test
         if (old_tests.hasChild (new_test.getTag ())) {
 
           XMLTestNode old_test = old_tests.getChild (new_test.getTag ());
 
           int new_test_config = -1;
           for (int k = 0; k < old_test.numChildren (); ++k) {
             XMLTestNode old_test_entry = old_test.getChild (k);
 
             TEUCHOS_TEST_FOR_EXCEPTION(
               ! old_test_entry.hasChild ("TestConfiguration") ||
               ! new_test_entry.hasChild ("TestResults"),
               std::runtime_error, "A TestEntry needs to have a child "
               "\"TestConfiguration\" and a child \"TestResults\".");
 
             if (old_test_entry.getChild ("TestConfiguration").hasSameElements (new_test_entry.getChild ("TestConfiguration"))) {
               new_test_config = k;
             }
           }
 
           if (new_test_config < 0) {
             old_test.addChild (new_test_entry);
             return_value = PerfTestNewTestConfiguration;
           } else {
             bool deviation = false;
             XMLTestNode old_test_entry = old_test.getChild (new_test_config);
             XMLTestNode old_results = old_test_entry.getChild ("TestResults");
             XMLTestNode new_results = new_test_entry.getChild ("TestResults");
 
             // Compare all entries
             for (int old_r = 0; old_r < old_results.numChildren (); ++old_r) {
               XMLTestNode result_entry = old_results.getChild (old_r);
 
               // Finding entry with same name
               bool exists = new_results.hasChild (result_entry.getTag ());
 
               if (exists) {
                 std::string oldv_str = result_entry.getContentLine (0);
 
                 // If it is a time or result compare numeric values with tolerance
                 if((result_entry.getTag().find("Time")==0) || (result_entry.getTag().find("Result")==0)) {
                   ValueTolerance old_valtol(oldv_str);
                   ValueTolerance new_valtol(new_results.getChild(result_entry.getTag()).getContentLine(0));
 
                   if(old_valtol.use_tolerance) {
                     double diff = old_valtol.value - new_valtol.value;
                     diff*=diff;
 
                     double normalization = old_valtol.value;
                     normalization*=normalization;
 
                     if(normalization==0?diff>0:diff/normalization>old_valtol.tolerance*old_valtol.tolerance) {
                       deviation = true;
                       std::cout << std::endl
                           << "DeviationA in Test: \"" << old_test.getTag()
                           << "\" for entry \"" <<  result_entry.getTag() << "\"" << std::endl;
                       std::cout << "  Existing Value: \"" << oldv_str << "\"" << std::endl;
                       std::cout << "  New Value:      \"" << new_results.getChild(result_entry.getTag()).getContentLine(0) << "\"" << std::endl << std::endl;
                     }
                   } else {
                     if( (old_valtol.lower>new_valtol.value) || (old_valtol.upper<new_valtol.value)) {
                       deviation = true;
                       std::cout << std::endl
                           << "DeviationB in Test: \"" << old_test.getTag()
                           << "\" for entry \"" <<  result_entry.getTag() << "\"" << std::endl;
                       std::cout << "  Existing Value: \"" << oldv_str << "\"" << std::endl;
                       std::cout << "  New Value:      \"" << new_results.getChild(result_entry.getTag()).getContentLine(0) << "\"" << std::endl << std::endl;
                     }
                   }
                 } else {
                   // Compare exact match for every other type of entry
                   if(oldv_str.compare(new_results.getChild(result_entry.getTag()).getContentLine(0))!=0) {
                     deviation = true;
                     std::cout << std::endl
                         << "DeviationC in Test: \"" << old_test.getTag()
                         << "\" for entry \"" <<  result_entry.getTag() << "\"" << std::endl;
                     std::cout << "  Existing Value: \"" << oldv_str << "\"" << std::endl;
                     std::cout << "  New Value:      \"" << new_results.getChild(result_entry.getTag()).getContentLine(0) << "\"" << std::endl << std::endl;
                   }
                 }
               }
               // An old value was not given in the new test: this is an error;
               if(!exists) {
                 std::cout << "Error New test has same name as an existing one, but one of the old entries is missing." << std::endl;
                 deviation = true;
               }
             }
 
             if(deviation) { return_value = PerfTestFailed; }
             else {
               // Did someone add new values to the test?
               if(new_results.numChildren()!=old_results.numChildren()) {
                 for(int new_r = 0; new_r < new_results.numChildren() ; new_r++) {
                   if(!old_results.hasChild(new_results.getChild(new_r).getTag())) {
                     old_results.addChild(new_results.getChild(new_r));
                   }
                 }
 
                 return_value = PerfTestUpdatedTest;
               }
             }
           }
         } else { // End Test Exists
           // Add new test if no match was found
           old_tests.addChild(new_test);
           return_value = PerfTestNewTest;
         }
       } // End MachineConfiguration Exists
     } // End loop over MachineConfigurations
 
     // Did not find matching MachineConfiguration
     if(is_new_config) {
       XMLTestNode config("Configuration");
       config.addChild(machine_config);
       XMLTestNode tests("Tests");
       tests.addChild(new_test);
 
       config.addChild(tests);
       machine.addChild(config);
 
       return_value = PerfTestNewConfiguration;
     }
   } else { // Machine Entry does not exist
     XMLTestNode machine(hostname);
 
     XMLTestNode config("Configuration");
     config.addChild(machine_config);
     XMLTestNode tests("Tests");
     tests.addChild(new_test);
     config.addChild(tests);
 
     machine.addChild(config);
 
     database.addChild(machine);
 
     return_value = PerfTestNewMachine;
   }
 
 
   if(return_value>PerfTestPassed) {
     std::ofstream fout(filename.c_str());
     fout << database << std::endl;
   }
 
   return return_value;
 }

Here is the call graph for this function:

◆ PerfTest_MachineConfig()

XMLTestNode Teuchos::PerfTest_MachineConfig ( )

PerfTest_MachineConfig generates a basic machine configuration XMLTestNode.

The function provides a starting point for a machine configuration. Users should add new entries to the returned XMLTestNode to provide test relevant machine configuration entries. For example Kokkos users might want to provide the name of the user Kokkos NodeType or Kokkos DeviceType. The returned config contains information mostly extracted from /proc/cpuinfo if possible. On non unix systems most values will be unknown. Entries are:

Compiler: The compiler name.
Compiler_Version: A compiler version number.
CPU_Name: The CPUs model name.
CPU_Sockets: Number of CPU sockets in the system.
CPU_Cores_Per_Socket: Number of CPU cores per socket.
CPU_Total_HyperThreads: Total number of threads in a node.

Definition at line 198 of file Teuchos_XMLPerfTestArchive.cpp.

                                      {
 
   // Get CPUName, Number of Sockets, Number of Cores, Number of Hyperthreads
   std::string cpuname("Undefined");
   unsigned int threads = 0;
   unsigned int cores_per_socket = 0;
   unsigned int highest_socketid = 0;
 
   {
     std::ifstream cpuinfo("/proc/cpuinfo");
     std::string line;
     if((cpuinfo.rdstate()&cpuinfo.failbit)) std::cout<<"Failed to open filen\n";
     while (!cpuinfo.eof() && !(cpuinfo.rdstate()&cpuinfo.failbit)) {
       getline (cpuinfo,line);
       if (line.find("model name") < line.size()) {
         cpuname = line.substr(line.find(":")+2);
         threads++;
       }
       if (line.find("physical id") < line.size()) {
         unsigned int socketid = atoi(line.substr(line.find(":")+2).c_str());
         highest_socketid = highest_socketid>socketid?highest_socketid:socketid;
       }
       if (line.find("cpu cores") < line.size()) {
         cores_per_socket = atoi(line.substr(line.find(":")+2).c_str());
       }
     }
   }
 
 
   XMLTestNode machine_config("MachineConfiguration");
 
   machine_config.addString("Compiler", TEUCHOS_COMPILER_NAME);
   machine_config.addInt("Compiler_Version",  TEUCHOS_COMPILER_VERSION);
   machine_config.addString("CPU_Name", cpuname);
   machine_config.addInt("CPU_Sockets", highest_socketid+1);
   machine_config.addInt("CPU_Cores_Per_Socket", cores_per_socket);
   machine_config.addInt("CPU_Total_HyperThreads", threads);
   return machine_config;
 }

◆ printValidParameters()

void Teuchos::printValidParameters	(	const ParameterListAcceptor &	paramListAccpetor,
		std::ostream &	out,
		const bool	showDoc = `true`
	)

Pretty print the valid parameters from a ParameterListAccpetor object.

Definition at line 48 of file Teuchos_ParameterListAcceptorHelpers.cpp.

 {
   typedef ParameterList::PrintOptions PLPrintOptions;
   paramListAccpetor.getValidParameters()->print(
     out, PLPrintOptions().indent(2).showTypes(true).showDoc(showDoc)
     );
 }

Here is the call graph for this function:

◆ PT_SPEC() [1/4]

Teuchos::PT_SPEC	(	double	,
		std::complex< float >	,
		std::complex< double >
	)

◆ PT_SPEC() [2/4]

std::complex<double> Teuchos::PT_SPEC	(	float	,
		std::complex< float >	,
		std::complex< float >
	)

◆ PT_SPEC() [3/4]

std::complex<double> std::complex<double> Teuchos::PT_SPEC	(	double	,
		float	,
		double
	)

◆ PT_SPEC() [4/4]

std::complex<double> std::complex<double> double Teuchos::PT_SPEC	(	double	,
		int	,
		double
	)

◆ RANGE_VALIDATOR_TEST()

Teuchos::RANGE_VALIDATOR_TEST ( int )

Here is the caller graph for this function:

◆ rcp()

template<class T , class Dealloc_T >

TEUCHOS_DEPRECATED RCP<T> Teuchos::rcp	(	T *	p,
		Dealloc_T	dealloc,
		bool	owns_mem
	)

inline

Deprecated.

Definition at line 1219 of file Teuchos_RCPDecl.hpp.

 {
   return rcpWithDealloc(p, dealloc, owns_mem);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RCP_createNewDeallocRCPNodeRawPtr()

template<class T , class Dealloc_T >

RCPNode* Teuchos::RCP_createNewDeallocRCPNodeRawPtr	(	T *	p,
		Dealloc_T	dealloc,
		bool	has_ownership_in
	)

inline

Definition at line 99 of file Teuchos_RCP.hpp.

 {
   return new RCPNodeTmpl<T,Dealloc_T>(p, dealloc, has_ownership_in);
 }

Here is the caller graph for this function:

◆ RCP_createNewDeallocRCPNodeRawPtrUndefined()

template<class T , class Dealloc_T >

RCPNode* Teuchos::RCP_createNewDeallocRCPNodeRawPtrUndefined	(	T *	p,
		Dealloc_T	dealloc,
		bool	has_ownership_in
	)

inline

Definition at line 109 of file Teuchos_RCP.hpp.

 {
   return new RCPNodeTmpl<T,Dealloc_T>(p, dealloc, has_ownership_in, null);
 }

Here is the caller graph for this function:

◆ RCP_createNewRCPNodeRawPtr()

template<class T >

RCPNode* Teuchos::RCP_createNewRCPNodeRawPtr	(	T *	p,
		bool	has_ownership_in
	)

inline

Definition at line 91 of file Teuchos_RCP.hpp.

 {
   return new RCPNodeTmpl<T,DeallocDelete<T> >(p, DeallocDelete<T>(), has_ownership_in);
 }

Here is the caller graph for this function:

◆ RCP_createNewRCPNodeRawPtrNonowned()

template<class T >

RCPNode* Teuchos::RCP_createNewRCPNodeRawPtrNonowned ( T * p )

inline

Definition at line 75 of file Teuchos_RCP.hpp.

 {
   return new RCPNodeTmpl<T,DeallocNull<T> >(p, DeallocNull<T>(), false);
 }

Here is the caller graph for this function:

◆ RCP_createNewRCPNodeRawPtrNonownedUndefined()

template<class T >

RCPNode* Teuchos::RCP_createNewRCPNodeRawPtrNonownedUndefined ( T * p )

inline

Definition at line 83 of file Teuchos_RCP.hpp.

 {
   return new RCPNodeTmpl<T,DeallocNull<T> >(p, DeallocNull<T>(), false, null);
 }

◆ readySend() [1/2]

template<typename Ordinal , class ViewType >

std::enable_if<(Kokkos::Impl::is_view<ViewType>::value)>::type Teuchos::readySend	(	const ViewType &	sendBuffer,
		const Ordinal	count,
		const int	destRank,
		const int	tag,
		const Comm< Ordinal > &	comm
	)

Variant of readySend() that accepts a message tag.

Definition at line 89 of file Kokkos_TeuchosCommAdapters.hpp.

 {
   readySend(sendBuffer.ptr_on_device(), count, destRank, tag, comm);
 }

Here is the call graph for this function:

◆ readySend() [2/2]

template<typename Ordinal , typename Packet >

void Teuchos::readySend	(	const Packet	sendBuffer[],
		const Ordinal	count,
		const int	destRank,
		const int	tag,
		const Comm< Ordinal > &	comm
	)

Variant of readySend() that accepts a message tag.

Definition at line 2502 of file Teuchos_CommHelpers.hpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::CommHelpers: readySend<"
     <<OrdinalTraits<Ordinal>::name()<<","<<TypeNameTraits<Packet>::name()
     <<">( value type )"
     );
   typedef ConstValueTypeSerializationBuffer<Ordinal, Packet> buf_type;
   buf_type charSendBuffer (count, sendBuffer);
   comm.readySend (charSendBuffer.getBytes (),
                   charSendBuffer.getCharBuffer (),
                   destRank, tag);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduce< int, int >() [1/2]

template<>

void Teuchos::reduce< int, int >	(	const int	sendBuf[],
		int	recvBuf[],
		const int	count,
		const EReductionType	reductType,
		const int	root,
		const Comm< int > &	comm
	)

Definition at line 1512 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR
     ("Teuchos::reduce<int, int> (" << count << ", " << toString (reductType)
      << ")");
   reduceImpl<int> (sendBuf, recvBuf, count, reductType, root, comm);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduce< int, int >() [2/2]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::reduce< int, int >	(	const int	sendBuf[],
		int	recvBuf[],
		const int	count,
		const EReductionType	reductType,
		const int	root,
		const Comm< int > &	comm
	)

Definition at line 1512 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR
     ("Teuchos::reduce<int, int> (" << count << ", " << toString (reductType)
      << ")");
   reduceImpl<int> (sendBuf, recvBuf, count, reductType, root, comm);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll() [1/3]

template<typename Ordinal , typename SendViewType , typename RecvViewType >

std::enable_if<(Kokkos::Impl::is_view<SendViewType>::value && Kokkos::Impl::is_view<RecvViewType>::value)>::type Teuchos::reduceAll	(	const SendViewType &	sendBuf,
		const RecvViewType &	recvBuf,
		const EReductionType	reductionType,
		const Comm< Ordinal > &	comm
	)

Definition at line 125 of file Kokkos_TeuchosCommAdapters.hpp.

 {
   // We can't use the array of intrinsic scalar type
   // ((non_)const_array_intrinsic_type) here, because we're doing a
   // reduction.  That means we need to compute with the actual value
   // type.
   typedef typename SendViewType::value_type send_value_type;
   typedef typename RecvViewType::value_type recv_value_type;
 
   const bool typesDiffer =
     ! Kokkos::Impl::is_same<send_value_type, recv_value_type>::value;
   TEUCHOS_TEST_FOR_EXCEPTION(
     typesDiffer, std::invalid_argument, "Teuchos::reduceAll: Send and receive "
     "Views contain data of different types.");
   TEUCHOS_TEST_FOR_EXCEPTION(
     SendViewType::rank > 1 || RecvViewType::rank > 1, std::invalid_argument,
     "Teuchos::reduceAll: Both send and receive Views must have rank 1.  "
     "The send View's rank is " << SendViewType::rank << " and the receive "
     "View's rank is " << RecvViewType::rank << ".");
   TEUCHOS_TEST_FOR_EXCEPTION(
     sendBuf.dimension_0 () != recvBuf.dimension_0 (), std::invalid_argument,
     "Send and receive buffer lengths do not match.  sendBuf.dimension_0() = "
     << sendBuf.dimension_0 () << " != recvBuf.dimension_0() = "
     << recvBuf.dimension_0 () << ".");
 
   // mfh 04 Nov 2014: Don't let Teuchos::SerialComm do a deep copy;
   // that always happens on the host, since SerialComm doesn't know
   // about Kokkos.
   if (comm.getSize () == 1) {
     Kokkos::deep_copy (recvBuf, sendBuf);
   }
   else {
     const Ordinal count = static_cast<Ordinal> (sendBuf.dimension_0 ());
     reduceAll (comm, reductionType, count,
                sendBuf.ptr_on_device (),
                recvBuf.ptr_on_device ());
   }
 }

Here is the call graph for this function:

◆ reduceAll() [2/3]

template<typename Ordinal , typename Serializer , class SendViewType , class RecvViewType >

std::enable_if<(Kokkos::Impl::is_view<SendViewType>::value && Kokkos::Impl::is_view<RecvViewType>::value)>::type Teuchos::reduceAll	(	const Comm< Ordinal > &	comm,
		const Serializer &	serializer,
		const EReductionType	reductType,
		const Ordinal	count,
		const SendViewType &	sendBuffer,
		const RecvViewType &	recvBuffer
	)

Definition at line 171 of file Kokkos_TeuchosCommAdapters.hpp.

 {
   // We can't use the array of intrinsic scalar type
   // ((non_)const_array_intrinsic_type) here, because we're doing a
   // reduction.  That means we need to compute with the actual value
   // type.
   typedef typename SendViewType::value_type send_value_type;
   typedef typename RecvViewType::value_type recv_value_type;
 
   const bool typesDiffer =
     ! Kokkos::Impl::is_same<send_value_type, recv_value_type>::value;
   TEUCHOS_TEST_FOR_EXCEPTION(
     typesDiffer, std::invalid_argument, "Teuchos::reduceAll: Send and receive "
     "Views contain data of different types.");
   TEUCHOS_TEST_FOR_EXCEPTION(
     SendViewType::rank > 1 || RecvViewType::rank > 1, std::invalid_argument,
     "Teuchos::reduceAll: Both send and receive Views must have rank 1.  "
     "The send View's rank is " << SendViewType::rank << " and the receive "
     "View's rank is " << RecvViewType::rank << ".");
 
   // mfh 04 Nov 2014: Don't let Teuchos::SerialComm do a deep copy;
   // that always happens on the host, since SerialComm doesn't know
   // about Kokkos.
   if (comm.getSize () == 1) {
     Kokkos::deep_copy (recvBuffer, sendBuffer);
   }
   else {
     reduceAll (comm, serializer, reductType, count,
                sendBuffer.ptr_on_device (),
                recvBuffer.ptr_on_device ());
   }
 }

Here is the call graph for this function:

◆ reduceAll() [3/3]

template<typename Ordinal , typename Packet >

TEUCHOS_DEPRECATED void Teuchos::reduceAll	(	const Comm< Ordinal > &	comm,
		const EReductionType	reductType,
		const Packet &	send,
		Packet *	globalReduct
	)

Deprecated .

Definition at line 377 of file Teuchos_CommHelpers.hpp.

 {
   reduceAll<Ordinal,Packet>(comm, reductType, send, ptr(globalReduct));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, char >() [1/2]

template<>

void Teuchos::reduceAll< int, char >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const char	sendBuffer[],
		char	globalReducts[]
	)

Definition at line 1791 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, char> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<char> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, char >() [2/2]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::reduceAll< int, char >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const char	sendBuffer[],
		char	globalReducts[]
	)

Definition at line 1791 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, char> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<char> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, double >() [1/2]

template<>

void Teuchos::reduceAll< int, double >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const double	sendBuffer[],
		double	globalReducts[]
	)

Definition at line 961 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, double> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<double> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, double >() [2/2]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::reduceAll< int, double >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const double	sendBuffer[],
		double	globalReducts[]
	)

Definition at line 961 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, double> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<double> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, float >() [1/2]

template<>

void Teuchos::reduceAll< int, float >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const float	sendBuffer[],
		float	globalReducts[]
	)

Definition at line 1029 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, float> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<float> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, float >() [2/2]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::reduceAll< int, float >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const float	sendBuffer[],
		float	globalReducts[]
	)

Definition at line 1029 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, float> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<float> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, int >() [1/2]

template<>

void Teuchos::reduceAll< int, int >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const int	sendBuffer[],
		int	globalReducts[]
	)

Definition at line 1527 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, int> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<int> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, int >() [2/2]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::reduceAll< int, int >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const int	sendBuffer[],
		int	globalReducts[]
	)

Definition at line 1527 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, int> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<int> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, long >() [1/2]

template<>

void Teuchos::reduceAll< int, long >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const long	sendBuffer[],
		long	globalReducts[]
	)

Definition at line 1313 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, long> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<long> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, long >() [2/2]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::reduceAll< int, long >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const long	sendBuffer[],
		long	globalReducts[]
	)

Definition at line 1313 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, long> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<long> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, long long >() [1/2]

template<>

void Teuchos::reduceAll< int, long long >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const long long	sendBuffer[],
		long long	globalReducts[]
	)

Definition at line 1124 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, long long> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<long long> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, long long >() [2/2]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::reduceAll< int, long long >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const long long	sendBuffer[],
		long long	globalReducts[]
	)

Definition at line 1124 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, long long> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<long long> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, short >() [1/2]

template<>

void Teuchos::reduceAll< int, short >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const short	sendBuffer[],
		short	globalReducts[]
	)

Definition at line 1714 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, short> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<short> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, short >() [2/2]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::reduceAll< int, short >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const short	sendBuffer[],
		short	globalReducts[]
	)

Definition at line 1714 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, short> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<short> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, std::complex< double > >() [1/2]

template<>

void Teuchos::reduceAll< int, std::complex< double > >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const std::complex< double >	sendBuffer[],
		std::complex< double >	globalReducts[]
	)

Definition at line 822 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, std::complex<double> > (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<std::complex<double> > (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

◆ reduceAll< int, std::complex< double > >() [2/2]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::reduceAll< int, std::complex< double > >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const std::complex< double >	sendBuffer[],
		std::complex< double >	globalReducts[]
	)

Definition at line 822 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, std::complex<double> > (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<std::complex<double> > (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

◆ reduceAll< int, std::complex< float > >() [1/2]

template<>

void Teuchos::reduceAll< int, std::complex< float > >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const std::complex< float >	sendBuffer[],
		std::complex< float >	globalReducts[]
	)

Definition at line 890 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, std::complex<float> > (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<std::complex<float> > (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

◆ reduceAll< int, std::complex< float > >() [2/2]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::reduceAll< int, std::complex< float > >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const std::complex< float >	sendBuffer[],
		std::complex< float >	globalReducts[]
	)

Definition at line 890 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, std::complex<float> > (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<std::complex<float> > (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

◆ reduceAll< int, unsigned int >() [1/2]

template<>

void Teuchos::reduceAll< int, unsigned int >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const unsigned int	sendBuffer[],
		unsigned int	globalReducts[]
	)

Definition at line 1620 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, unsigned int> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<unsigned int> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, unsigned int >() [2/2]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::reduceAll< int, unsigned int >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const unsigned int	sendBuffer[],
		unsigned int	globalReducts[]
	)

Definition at line 1620 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, unsigned int> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<unsigned int> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, unsigned long >() [1/2]

template<>

void Teuchos::reduceAll< int, unsigned long >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const unsigned long	sendBuffer[],
		unsigned long	globalReducts[]
	)

Definition at line 1407 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, unsigned long> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<unsigned long> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, unsigned long >() [2/2]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::reduceAll< int, unsigned long >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const unsigned long	sendBuffer[],
		unsigned long	globalReducts[]
	)

Definition at line 1407 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, unsigned long> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<unsigned long> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, unsigned long long >() [1/2]

template<>

void Teuchos::reduceAll< int, unsigned long long >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const unsigned long long	sendBuffer[],
		unsigned long long	globalReducts[]
	)

Definition at line 1217 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, unsigned long long> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<unsigned long long> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reduceAll< int, unsigned long long >() [2/2]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::reduceAll< int, unsigned long long >	(	const Comm< int > &	comm,
		const EReductionType	reductType,
		const int	count,
		const unsigned long long	sendBuffer[],
		unsigned long long	globalReducts[]
	)

Definition at line 1217 of file Teuchos_CommHelpers.cpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::reduceAll<int, unsigned long long> (" << count << ", "
     << toString (reductType) << ")"
     );
   reduceAllImpl<unsigned long long> (comm, reductType, count, sendBuffer, globalReducts);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ relErr()

template<class Scalar >

ScalarTraits<Scalar>::magnitudeType Teuchos::relErr	(	const Scalar &	s1,
		const Scalar &	s2
	)

Return relative error of two scalars.

ToDo: Finish documentation!

Here is the caller graph for this function:

◆ scan()

template<typename Ordinal , typename Packet >

TEUCHOS_DEPRECATED void Teuchos::scan	(	const Comm< Ordinal > &	comm,
		const EReductionType	reductType,
		const Packet &	send,
		Packet *	scanReduct
	)

Deprecated.

Definition at line 458 of file Teuchos_CommHelpers.hpp.

 {
   scan(comm, reductType, send, ptr(scanReduct));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scatter()

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::scatter	(	const int	sendBuf[],
		const int	sendCount,
		int	recvBuf[],
		const int	recvCount,
		const int	root,
		const Comm< int > &	comm
	)

Here is the caller graph for this function:

◆ scatter< int, int >()

template<>

void Teuchos::scatter< int, int >	(	const int	sendBuf[],
		const int	sendCount,
		int	recvBuf[],
		const int	recvCount,
		const int	root,
		const Comm< int > &	comm
	)

Definition at line 1500 of file Teuchos_CommHelpers.cpp.

 {
   scatterImpl<int> (sendBuf, sendCount, recvBuf, recvCount, root, comm);
 }

◆ send() [1/2]

template<typename Ordinal , class ViewType >

std::enable_if<(Kokkos::Impl::is_view<ViewType>::value)>::type Teuchos::send	(	const ViewType &	sendBuffer,
		const Ordinal	count,
		const int	destRank,
		const int	tag,
		const Comm< Ordinal > &	comm
	)

Variant of send() that takes a tag (and restores the correct order of arguments).

Definition at line 65 of file Kokkos_TeuchosCommAdapters.hpp.

 {
   send(sendBuffer.ptr_on_device(), count, destRank, tag, comm);
 }

Here is the call graph for this function:

◆ send() [2/2]

template<typename Ordinal , typename Packet >

void Teuchos::send	(	const Packet	sendBuffer[],
		const Ordinal	count,
		const int	destRank,
		const int	tag,
		const Comm< Ordinal > &	comm
	)

Variant of send() that takes a tag (and restores the correct order of arguments).

Definition at line 2323 of file Teuchos_CommHelpers.hpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::CommHelpers: send<"
     <<OrdinalTraits<Ordinal>::name()<<","<<TypeNameTraits<Packet>::name()
     <<">( value type )"
     );
   ConstValueTypeSerializationBuffer<Ordinal,Packet> charSendBuffer (count, sendBuffer);
   comm.send (charSendBuffer.getBytes (), charSendBuffer.getCharBuffer (), destRank, tag);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send< int, double >() [1/4]

template<>

void Teuchos::send< int, double >	(	const Comm< int > &	comm,
		const int	count,
		const double	sendBuffer[],
		const int	destRank
	)

Definition at line 997 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<double> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, double >() [2/4]

template<>

void Teuchos::send< int, double >	(	const double	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1007 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<double> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, double >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, double >	(	const Comm< int > &	comm,
		const int	count,
		const double	sendBuffer[],
		const int	destRank
	)

Definition at line 997 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<double> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, double >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, double >	(	const double	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1007 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<double> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, float >() [1/4]

template<>

void Teuchos::send< int, float >	(	const Comm< int > &	comm,
		const int	count,
		const float	sendBuffer[],
		const int	destRank
	)

Definition at line 1065 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<float> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, float >() [2/4]

template<>

void Teuchos::send< int, float >	(	const float	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1075 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<float> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, float >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, float >	(	const Comm< int > &	comm,
		const int	count,
		const float	sendBuffer[],
		const int	destRank
	)

Definition at line 1065 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<float> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, float >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, float >	(	const float	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1075 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<float> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, int >() [1/4]

template<>

void Teuchos::send< int, int >	(	const Comm< int > &	comm,
		const int	count,
		const int	sendBuffer[],
		const int	destRank
	)

Definition at line 1563 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<int> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, int >() [2/4]

template<>

void Teuchos::send< int, int >	(	const int	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1573 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<int> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, int >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, int >	(	const Comm< int > &	comm,
		const int	count,
		const int	sendBuffer[],
		const int	destRank
	)

Definition at line 1563 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<int> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, int >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, int >	(	const int	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1573 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<int> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, long >() [1/4]

template<>

void Teuchos::send< int, long >	(	const Comm< int > &	comm,
		const int	count,
		const long	sendBuffer[],
		const int	destRank
	)

Definition at line 1349 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<long> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, long >() [2/4]

template<>

void Teuchos::send< int, long >	(	const long	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1359 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<long> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, long >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, long >	(	const Comm< int > &	comm,
		const int	count,
		const long	sendBuffer[],
		const int	destRank
	)

Definition at line 1349 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<long> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, long >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, long >	(	const long	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1359 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<long> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, long long >() [1/4]

template<>

void Teuchos::send< int, long long >	(	const Comm< int > &	comm,
		const int	count,
		const long long	sendBuffer[],
		const int	destRank
	)

Definition at line 1160 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<long long> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, long long >() [2/4]

template<>

void Teuchos::send< int, long long >	(	const long long	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1170 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<long long> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, long long >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, long long >	(	const Comm< int > &	comm,
		const int	count,
		const long long	sendBuffer[],
		const int	destRank
	)

Definition at line 1160 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<long long> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, long long >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, long long >	(	const long long	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1170 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<long long> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, short >() [1/4]

template<>

void Teuchos::send< int, short >	(	const Comm< int > &	comm,
		const int	count,
		const short	sendBuffer[],
		const int	destRank
	)

Definition at line 1750 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<short> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, short >() [2/4]

template<>

void Teuchos::send< int, short >	(	const short	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1760 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<short> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, short >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, short >	(	const Comm< int > &	comm,
		const int	count,
		const short	sendBuffer[],
		const int	destRank
	)

Definition at line 1750 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<short> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, short >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, short >	(	const short	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1760 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<short> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, std::complex< double > >() [1/4]

template<>

void Teuchos::send< int, std::complex< double > >	(	const Comm< int > &	comm,
		const int	count,
		const std::complex< double >	sendBuffer[],
		const int	destRank
	)

Definition at line 858 of file Teuchos_CommHelpers.cpp.

 {
   sendImpl<std::complex<double> > (comm, count, sendBuffer, destRank);
 }

◆ send< int, std::complex< double > >() [2/4]

template<>

void Teuchos::send< int, std::complex< double > >	(	const std::complex< double >	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 868 of file Teuchos_CommHelpers.cpp.

 {
   sendImpl<std::complex<double> > (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, std::complex< double > >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, std::complex< double > >	(	const Comm< int > &	comm,
		const int	count,
		const std::complex< double >	sendBuffer[],
		const int	destRank
	)

Definition at line 858 of file Teuchos_CommHelpers.cpp.

 {
   sendImpl<std::complex<double> > (comm, count, sendBuffer, destRank);
 }

◆ send< int, std::complex< double > >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, std::complex< double > >	(	const std::complex< double >	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 868 of file Teuchos_CommHelpers.cpp.

 {
   sendImpl<std::complex<double> > (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, std::complex< float > >() [1/4]

template<>

void Teuchos::send< int, std::complex< float > >	(	const Comm< int > &	comm,
		const int	count,
		const std::complex< float >	sendBuffer[],
		const int	destRank
	)

Definition at line 926 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<std::complex<float> > (comm, count, sendBuffer, destRank);
 }

◆ send< int, std::complex< float > >() [2/4]

template<>

void Teuchos::send< int, std::complex< float > >	(	const std::complex< float >	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 936 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<std::complex<float> > (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, std::complex< float > >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, std::complex< float > >	(	const Comm< int > &	comm,
		const int	count,
		const std::complex< float >	sendBuffer[],
		const int	destRank
	)

Definition at line 926 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<std::complex<float> > (comm, count, sendBuffer, destRank);
 }

◆ send< int, std::complex< float > >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, std::complex< float > >	(	const std::complex< float >	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 936 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<std::complex<float> > (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, unsigned int >() [1/4]

template<>

void Teuchos::send< int, unsigned int >	(	const Comm< int > &	comm,
		const int	count,
		const unsigned int	sendBuffer[],
		const int	destRank
	)

Definition at line 1656 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<unsigned int> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, unsigned int >() [2/4]

template<>

void Teuchos::send< int, unsigned int >	(	const unsigned int	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1666 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<unsigned int> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, unsigned int >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, unsigned int >	(	const Comm< int > &	comm,
		const int	count,
		const unsigned int	sendBuffer[],
		const int	destRank
	)

Definition at line 1656 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<unsigned int> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, unsigned int >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, unsigned int >	(	const unsigned int	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1666 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<unsigned int> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, unsigned long >() [1/4]

template<>

void Teuchos::send< int, unsigned long >	(	const Comm< int > &	comm,
		const int	count,
		const unsigned long	sendBuffer[],
		const int	destRank
	)

Definition at line 1443 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<unsigned long> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, unsigned long >() [2/4]

template<>

void Teuchos::send< int, unsigned long >	(	const unsigned long	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1453 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<unsigned long> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, unsigned long >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, unsigned long >	(	const Comm< int > &	comm,
		const int	count,
		const unsigned long	sendBuffer[],
		const int	destRank
	)

Definition at line 1443 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<unsigned long> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, unsigned long >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, unsigned long >	(	const unsigned long	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1453 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<unsigned long> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, unsigned long long >() [1/4]

template<>

void Teuchos::send< int, unsigned long long >	(	const Comm< int > &	comm,
		const int	count,
		const unsigned long long	sendBuffer[],
		const int	destRank
	)

Definition at line 1253 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<unsigned long long> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, unsigned long long >() [2/4]

template<>

void Teuchos::send< int, unsigned long long >	(	const unsigned long long	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1263 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<unsigned long long> (sendBuffer, count, destRank, tag, comm);
 }

◆ send< int, unsigned long long >() [3/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, unsigned long long >	(	const Comm< int > &	comm,
		const int	count,
		const unsigned long long	sendBuffer[],
		const int	destRank
	)

Definition at line 1253 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<unsigned long long> (comm, count, sendBuffer, destRank);
 }

Here is the caller graph for this function:

◆ send< int, unsigned long long >() [4/4]

template<>

TEUCHOSCOMM_LIB_DLL_EXPORT void Teuchos::send< int, unsigned long long >	(	const unsigned long long	sendBuffer[],
		const int	count,
		const int	destRank,
		const int	tag,
		const Comm< int > &	comm
	)

Definition at line 1263 of file Teuchos_CommHelpers.cpp.

 {
   return sendImpl<unsigned long long> (sendBuffer, count, destRank, tag, comm);
 }

◆ set() [1/12]

testList Teuchos::set	(	paramName1	,
		paramValue1
	)

◆ set() [2/12]

testList Teuchos::set	(	paramName2	,
		paramValue2
	)

◆ set() [3/12]

testList Teuchos::set	(	dependent1Name	,
		dependentValue
	)

◆ set() [4/12]

myDepList Teuchos::set	(	dependee1	,
		"val1"
	)

◆ set() [5/12]

myDepList Teuchos::set	(	dependee2	,
		true
	)

◆ set() [6/12]

myDepList Teuchos::set	(	dependee3	,
		1
	)

◆ set() [7/12]

myDepList Teuchos::set	(	dependent1	,
		1.	0
	)

◆ set() [8/12]

myDepList Teuchos::set	(	dependent2	,
		1.	0
	)

◆ set() [9/12]

myDepList Teuchos::set	(	dependent3	,
		(float) 1.	0
	)

◆ set() [10/12]

myDepList Teuchos::set	(	dependee2	,
		"val2"
	)

◆ set() [11/12]

myDepList Teuchos::set	(	dependent1	,
		2.	0
	)

◆ set() [12/12]

myDepList Teuchos::set	(	dependent2	,
		3.	0
	)

◆ showTestFailureLocation() [1/2]

void Teuchos::showTestFailureLocation ( bool showTFL )

Set if TEUCHOS_PASS_FAIL(...) should print test failure location.

Definition at line 72 of file Teuchos_TestingHelpers.cpp.

 {
   showTestFailureLocationImpl() = showTFL;
 }

Here is the caller graph for this function:

◆ showTestFailureLocation() [2/2]

bool Teuchos::showTestFailureLocation ( )

Return if TEUCHOS_PASS_FAIL(...) should print test failure location.

Definition at line 78 of file Teuchos_TestingHelpers.cpp.

 {
   return showTestFailureLocationImpl();
 }

◆ ssend() [1/2]

template<typename Ordinal , class ViewType >

std::enable_if<(Kokkos::Impl::is_view<ViewType>::value)>::type Teuchos::ssend	(	const ViewType &	sendBuffer,
		const Ordinal	count,
		const int	destRank,
		const int	tag,
		const Comm< Ordinal > &	comm
	)

Variant of ssend() that takes a tag (and restores the correct order of arguments).

Definition at line 77 of file Kokkos_TeuchosCommAdapters.hpp.

 {
   ssend(sendBuffer.ptr_on_device(), count, destRank, tag, comm);
 }

Here is the call graph for this function:

◆ ssend() [2/2]

template<typename Ordinal , typename Packet >

void Teuchos::ssend	(	const Packet	sendBuffer[],
		const Ordinal	count,
		const int	destRank,
		const int	tag,
		const Comm< Ordinal > &	comm
	)

Variant of ssend() that takes a tag (and restores the correct order of arguments).

Definition at line 2359 of file Teuchos_CommHelpers.hpp.

 {
   TEUCHOS_COMM_TIME_MONITOR(
     "Teuchos::CommHelpers: ssend<"
     <<OrdinalTraits<Ordinal>::name()<<","<<TypeNameTraits<Packet>::name()
     <<">( value type )"
     );
   typedef ConstValueTypeSerializationBuffer<Ordinal, Packet> buf_type;
   buf_type charSendBuffer (count, sendBuffer);
   comm.ssend (charSendBuffer.getBytes (),
               charSendBuffer.getCharBuffer (),
               destRank, tag);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ strMatch()

bool Teuchos::strMatch	(	const std::string &	fullMatchStr,
		const std::string &	str
	)

Definition at line 117 of file Teuchos_UnitTestRepository.cpp.

 {
 
   const std::string::size_type npos = std::string::npos;
 
   const int strLen = str.length();
   const int fullMatchStrLen = fullMatchStr.length();
 
   if (fullMatchStrLen == 0) {
     return true;
   }
 
   const bool beginGlob = fullMatchStr[0] == '*';
   const bool endGlob = fullMatchStr[fullMatchStrLen-1] == '*';
 
   const int matchStrLen =
     fullMatchStrLen + (beginGlob ? -1 : 0) + (endGlob ? -1 : 0);
 
   if (matchStrLen == 0) {
     return true;
   }
 
   if (matchStrLen > strLen) {
     return false;
   }
 
   if (beginGlob && endGlob) {
     return str.find(fullMatchStr.substr(1, matchStrLen)) != npos;
   }
 
   if (endGlob) {
     return fullMatchStr.substr(0, matchStrLen) == str.substr(0, matchStrLen);
   }
 
   if (beginGlob) {
     return fullMatchStr.substr(1, matchStrLen) ==
       str.substr(strLen-matchStrLen, matchStrLen);
   }
 
   return fullMatchStr == str;
 
 }

◆ TEST_ASSERT() [1/7]

Teuchos::TEST_ASSERT ( nonnull(readInCon) )

Here is the caller graph for this function:

◆ TEST_ASSERT() [2/7]

Teuchos::TEST_ASSERT ( readInConList. size() = =2 )

◆ TEST_ASSERT() [3/7]

Teuchos::TEST_ASSERT ( readinDep2. get() = =readinDep3.get() )

◆ TEST_ASSERT() [4/7]

Teuchos::TEST_ASSERT ( castedDep1-> getValuesAndValidators).size( = =2 )

◆ TEST_ASSERT() [5/7]

Teuchos::TEST_ASSERT ( castedDep2-> getValuesAndValidators).size( = =2 )

◆ TEST_ASSERT() [6/7]

Teuchos::TEST_ASSERT ( castedDep1-> getDefaultValidator).is_null( )

◆ TEST_ASSERT() [7/7]

Teuchos::TEST_ASSERT ( nonnull(castedDep2->getDefaultValidator()) )

◆ TEST_EQUALITY() [1/12]

Teuchos::TEST_EQUALITY	(	readInDep1.	get(),
		readInDep1.	get()
	)

Here is the caller graph for this function:

◆ TEST_EQUALITY() [2/12]

Teuchos::TEST_EQUALITY	(	readInDep1->	getCondition) ->getTypeAttributeValue(,
		DummyObjectGetter< BinCondition >	::getDummyObject) ->getTypeAttributeValue(
	)

◆ TEST_EQUALITY() [3/12]

Teuchos::TEST_EQUALITY	(	readInDep1->	getCondition) ->getTypeAttributeValue(,
		DummyObjectGetter< NotCondition >	::getDummyObject) ->getTypeAttributeValue(
	)

◆ TEST_EQUALITY() [4/12]

Teuchos::TEST_EQUALITY	(	castedDep1->	getShowIf(),
		simpleConVisDep->	getShowIf()
	)

◆ TEST_EQUALITY() [5/12]

Teuchos::TEST_EQUALITY	(	castedDep2->	getShowIf(),
		complexConVisDep->	getShowIf()
	)

◆ TEST_EQUALITY() [6/12]

Teuchos::TEST_EQUALITY	(	castedDep1->	getCondition) ->getTypeAttributeValue(,
		simpleConVisDep->	getCondition) ->getTypeAttributeValue(
	)

◆ TEST_EQUALITY() [7/12]

Teuchos::TEST_EQUALITY	(	castedDep2->	getCondition) ->getTypeAttributeValue(,
		complexConVisDep->	getCondition) ->getTypeAttributeValue(
	)

◆ TEST_EQUALITY() [8/12]

Teuchos::TEST_EQUALITY	(	rcp_dynamic_cast< const EnhancedNumberValidator< double > >	castedDep1->getValuesAndValidators().find("val1") ->second, true) ->getMax(,
		double1Vali->	getMax()
	)

◆ TEST_EQUALITY() [9/12]

Teuchos::TEST_EQUALITY	(	rcp_dynamic_cast< const EnhancedNumberValidator< double > >	castedDep2->getValuesAndValidators().find("val1") ->second, true) ->getMax(,
		double1Vali->	getMax()
	)

◆ TEST_EQUALITY() [10/12]

Teuchos::TEST_EQUALITY	(	rcp_dynamic_cast< const EnhancedNumberValidator< double > >	castedDep1->getValuesAndValidators().find("val2") ->second, true) ->getMax(,
		double2Vali->	getMax()
	)

◆ TEST_EQUALITY() [11/12]

Teuchos::TEST_EQUALITY	(	rcp_dynamic_cast< const EnhancedNumberValidator< double > >	castedDep2->getValuesAndValidators().find("val2") ->second, true) ->getMax(,
		double2Vali->	getMax()
	)

◆ TEST_EQUALITY() [12/12]

Teuchos::TEST_EQUALITY	(	rcp_dynamic_cast< const EnhancedNumberValidator< double > >	castedDep2->getDefaultValidator(), true) ->getMax(,
		defaultVali->	getMax()
	)

◆ TEST_THROW() [1/6]

Teuchos::TEST_THROW	(	RCP< ParameterList >	missingDependeeList = `getParametersFromXmlFile("MissingDependeeTag.xml", depSheet)`,
		MissingDependeesException
	)

Here is the caller graph for this function:

◆ TEST_THROW() [2/6]

Teuchos::TEST_THROW	(	RCP< ParameterList >	missingDependentsList = `getParametersFromXmlFile("MissingDependentTag.xml", depSheet)`,
		MissingDependentsException
	)

◆ TEST_THROW() [3/6]

Teuchos::TEST_THROW	(	RCP< ParameterList >	missingDependeeList = `getParametersFromXmlFile("MissingDependee.xml", depSheet)`,
		MissingDependeeException
	)

◆ TEST_THROW() [4/6]

Teuchos::TEST_THROW	(	RCP< ParameterList >	missingDependentList = `getParametersFromXmlFile("MissingDependent.xml", depSheet)`,
		MissingDependentException
	)

◆ TEST_THROW() [5/6]

Teuchos::TEST_THROW	(	boolVisConverter.	fromDependencytoXMLboolVisDep, entryIDsMap, validatorIDsMap,
		MissingDependeeException
	)

◆ TEST_THROW() [6/6]

Teuchos::TEST_THROW	(	boolVisConverter.	fromDependencytoXMLboolVisDep, entryIDsMap, validatorIDsMap,
		MissingDependentException
	)

◆ TestForException_getEnableStacktrace()

bool Teuchos::TestForException_getEnableStacktrace ( )

Get at runtime if stacktracing functionality is enabled when exceptions are thrown.

Definition at line 107 of file Teuchos_TestForException.cpp.

 {
   return loc_enableStackTrace();
 }

◆ testList()

ParameterList Teuchos::testList ( "Condition Test List" )

◆ testRelErr()

template<class Scalar >

bool Teuchos::testRelErr	(	const std::string &	v1_name,
		const Scalar &	v1,
		const std::string &	v2_name,
		const Scalar &	v2,
		const std::string &	maxRelErr_error_name,
		const typename Teuchos::ScalarTraits< Scalar >::magnitudeType &	maxRelErr_error,
		const std::string &	maxRelErr_warning_name,
		const typename Teuchos::ScalarTraits< Scalar >::magnitudeType &	maxRelErr_warning,
		const Ptr< std::ostream > &	out
	)

Compute, check and optionally print the relative error in two scalars.

ToDo: Finish documentation!

Definition at line 584 of file Teuchos_TestingHelpers.hpp.

 {
   using std::endl;
   typedef ScalarTraits<Scalar> ST;
   typedef typename ST::magnitudeType ScalarMag;
   typedef ScalarTraits<ScalarMag> SMT;
   const ScalarMag rel_err = relErr( v1, v2 );
   const bool success = ( !SMT::isnaninf(rel_err) && !SMT::isnaninf(maxRelErr_error)
     && rel_err <= maxRelErr_error );
   if (!is_null(out)) {
     *out
       << endl
       << "Check: rel_err(" << v1_name << ", " << v2_name << ")\n"
       << "       = rel_err(" << v1 << ", " << v2 << ") "
       << "= " << rel_err << endl
       << "         <= " << maxRelErr_error_name
       << " = " << maxRelErr_error << " : " << passfail(success) << endl;
     if( success && rel_err >= maxRelErr_warning ) {
       *out
         << "Warning! rel_err(" << v1_name << ", " << v2_name << ")\n"
         << "       = rel_err(" << v1 << ", " << v2 << ") "
         << "= " << rel_err << endl
         << "         >= " << maxRelErr_warning_name
         << " = " << maxRelErr_warning << "!\n";
     }
   }
   return success;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TEUCHOS_STATIC_SETUP()

Teuchos::TEUCHOS_STATIC_SETUP ( )

Definition at line 109 of file RCPNodeHandle_UnitTests.cpp.

110 {

111 }

Here is the caller graph for this function:

◆ TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION() [1/13]

Teuchos::TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION ( DummyNS::UndefinedType )

◆ TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION() [2/13]

Teuchos::TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION ( bool )

◆ TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION() [3/13]

Teuchos::TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION ( char )

◆ TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION() [4/13]

Teuchos::TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION ( signed char )

◆ TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION() [5/13]

Teuchos::TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION ( unsigned char )

◆ TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION() [6/13]

Teuchos::TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION ( short int )

◆ TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION() [7/13]

Teuchos::TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION ( int )

◆ TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION() [8/13]

Teuchos::TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION ( long int )

◆ TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION() [9/13]

Teuchos::TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION ( unsigned short int )

◆ TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION() [10/13]

Teuchos::TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION ( unsigned long int )

◆ TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION() [11/13]

Teuchos::TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION ( float )

◆ TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION() [12/13]

Teuchos::TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION ( double )

◆ TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION() [13/13]

Teuchos::TEUCHOS_TYPE_NAME_TRAITS_BUILTIN_TYPE_SPECIALIZATION ( __float128 )

◆ TEUCHOS_UNIT_TEST() [1/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		create
	)

Definition at line 48 of file ConstNonconstObjectContainer.cpp.

                                                           {
   ConstNonconstObjectContainer<std::vector<double> > vectorObj;
   RCP<std::vector<double> > vec = rcp(new std::vector<double> );
   vectorObj.initialize(vec); // nonconst
   TEST_ASSERT( vectorObj.isConst() == false );
 }

◆ TEUCHOS_UNIT_TEST() [2/224]

Teuchos::TEUCHOS_UNIT_TEST	(	OrdinalIndex	,
		defaultConstruct
	)

Definition at line 48 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   ECHO(SIOVOCB::OrdinalIndex idx);
   TEST_EQUALITY_CONST(idx.idx, -1); // Depends on implementation choice!
 }

◆ TEUCHOS_UNIT_TEST() [3/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ParameterEntry	,
		testTypeFunctions
	)

Definition at line 49 of file ParameterEntry_UnitTest.cpp.

 {
   ParameterEntry intEntry;
   intEntry.setValue(1);
   TEST_ASSERT(intEntry.isType<int>());
   TEST_ASSERT(!intEntry.isArray());
   TEST_ASSERT(!intEntry.isTwoDArray());
 
   ParameterEntry doubleEntry;
   doubleEntry.setValue(1.0);
   TEST_ASSERT(doubleEntry.isType<double>());
   TEST_ASSERT(!doubleEntry.isArray());
   TEST_ASSERT(!doubleEntry.isTwoDArray());
 
   Array<int> intArray = tuple<int>(1,2,3);
   ParameterEntry arrayEntry;
   arrayEntry.setValue(intArray);
   TEST_ASSERT(arrayEntry.isType<Array<int> >());
   TEST_ASSERT(arrayEntry.isArray());
   TEST_ASSERT(!arrayEntry.isTwoDArray());
 
   TwoDArray<double> twoDArray(3,3,3.0);
   ParameterEntry twoDEntry(twoDArray);
   TEST_ASSERT(twoDEntry.isType<TwoDArray<double> >());
   TEST_ASSERT(twoDEntry.isTwoDArray());
   TEST_ASSERT(!twoDEntry.isArray());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [4/224]

Teuchos::TEUCHOS_UNIT_TEST	(	XMLParameterListHelpers	,
		toFromFile
	)

Definition at line 49 of file XMLParameterListHelpers_UnitTest.cpp.

 {
 
   ParameterList A;
   A.sublist("SublistA").set("param_a", "a");
   A.sublist("SublistA").sublist("SublistB").set("param_b", "b");
   out << "\nA:\n"; A.print(out);
   writeParameterListToXmlFile(A, "A.xml");
 
   ParameterList B;
   updateParametersFromXmlFile("A.xml", inoutArg(B));
   out << "\nB:\n"; B.print(out);
   TEST_ASSERT( A == B );
 
 
   TEST_EQUALITY(
     getParameter<std::string>(B.sublist("SublistA", true), "param_a"),
     "a");
   TEST_EQUALITY(
     getParameter<std::string>(B.sublist("SublistA", true).sublist("SublistB", true), "param_b"),
     "b");
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [5/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Functions	,
		SubtractionTests
	)

Serialization Tests for subtraction functions

Tests for subtraction functions

Definition at line 53 of file FunctionObject_Serialization_UnitTests.cpp.

                                                       {
   RCP<SubtractionFunction<int> > intTester = rcp(
     new SubtractionFunction<int>(10));
 
   XMLObject subFuncXML = FunctionObjectXMLConverterDB::convertFunctionObject(
     intTester);
 
   std::string type = subFuncXML.getRequired(
     FunctionObjectXMLConverter::getTypeAttributeName());
   TEST_ASSERT(type == intTester->getTypeAttributeValue() );
   int operand = subFuncXML.getRequired<int>(
     SimpleFunctionXMLConverter<int>::getOperandAttributeName());
   TEST_ASSERT(operand == intTester->getModifiyingOperand());
 
   RCP<FunctionObject> readIn =
     FunctionObjectXMLConverterDB::convertXML(subFuncXML);
   RCP<SubtractionFunction<int> > readInCasted =
     rcp_dynamic_cast<SubtractionFunction<int> >(readIn);
   TEST_ASSERT(readInCasted.get() != NULL);
   TEST_ASSERT(
     readInCasted->getModifiyingOperand()
     ==
     intTester->getModifiyingOperand());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [6/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ParameterList	,
		xmlUpdateAndBroadcast
	)

Definition at line 53 of file ParameterList_UnitTest_Parallel.cpp.

                                                                   {
   const RCP<const Comm<int> > comm = DefaultComm<int>::getComm();
   // Test the broadcast functionality to avoid unscalable I/O collisions
   std::string inputFile="input.xml";
   ParameterList A;
   ParameterList B;
   updateParametersFromXmlFile(inputFile, outArg(A));
   updateParametersFromXmlFileAndBroadcast(inputFile, outArg(B), *comm);
   out << "B = " << B;
   TEST_ASSERT( B.begin() != B.end() ); // Avoid false positive from empty lists
 
   // See if any process returned a failed (i.e. a non-zero local_failed)
   const int local_failed = !(A == B);
   int global_failed = -1;
   reduceAll(*comm, Teuchos::REDUCE_SUM, local_failed, outArg(global_failed));
   TEST_EQUALITY_CONST(global_failed, 0);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [7/224]

Teuchos::TEUCHOS_UNIT_TEST	(	UnitTestHarness	,
		nonRootFails
	)

Definition at line 53 of file UnitTestHarness_Parallel_UnitTests.cpp.

                                                    {
   out << "Pass on even procs but fail on other procs!\n";
   const RCP<const Comm<int> > comm = DefaultComm<int>::getComm();
   const int procRank = comm->getRank();
   TEST_EQUALITY_CONST(procRank%2, 0);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [8/224]

Teuchos::TEUCHOS_UNIT_TEST	(	XMLParameterListHelpers	,
		anonymousSublists
	)

Definition at line 54 of file XMLParameterListHelpers_AnonSublists.cpp.

   {
     // the sublists are missing names; that is allowed now
     string anon_sublist(
       "<ParameterList name=\"Parent\">\n"
       "  <ParameterList>\n"
       "    <Parameter name=\"param_a\" type=\"string\" value=\"a\"/>\n"
       "    <ParameterList>\n"
       "      <Parameter name=\"param_b\" type=\"string\" value=\"b\"/>\n"
       "    </ParameterList>\n"
       "  </ParameterList>\n"
       "</ParameterList>\n");
     StringInputSource src(anon_sublist);
     XMLParser parser(src.stream());
     XMLObject xmlprob = parser.parse();
     XMLParameterListReader pl2xml;
     ParameterList plTest;
     TEST_NOTHROW( plTest = pl2xml.toParameterList(xmlprob) );
     out << plTest;
   }

◆ TEUCHOS_UNIT_TEST() [9/224]

Teuchos::TEUCHOS_UNIT_TEST	(	XMLParser	,
		simpletest
	)

Definition at line 54 of file XMLParser_test.cpp.

 {
 
   /* create a ParameterList object */
   ParameterList problem("Problem");
   ParameterList solver("Solver");
   ParameterList prec("Preconditioner");
   prec.set("type", "ILUk");           // set some of these to isUsed for completeness
   TEST_NOTHROW( prec.get<std::string>("type") );
   prec.set("k", 2);
   solver.set("Preconditioner",prec);
   solver.set("type", "gmres");        // set some of these to isUsed for completeness
   TEST_NOTHROW( solver.get<std::string>("type") );
   solver.set("maxiters", 1000);
   solver.set("restarts", 100);
   solver.set("special1","\"&\"");     // test the XML outputting and parsing for correctness
   solver.set("special2","\'&\'");     // test the XML outputting and parsing for correctness
   solver.set("special3","\"&\'");     // test the XML outputting and parsing for correctness
   solver.set("tol", 1.0e-10);         // set some of these to isUsed for completeness
   TEST_NOTHROW( solver.get<double>("tol") );
   problem.set("Solver",solver);
 
   std::cout << "*** ParameterList (original)" << std::endl;
   std::cout << problem << std::endl;
 
   /* create an XML object from the ParameterList */
   XMLParameterListWriter xml2pl;
   XMLObject xmlprob1 = xml2pl.toXML(problem);
 
   /* write the XML to a std::string */
   std::ostringstream ss;
   ss << xmlprob1;
   std::string strproblem = ss.str();
 
   std::cout << "*** XML from ParameterListParameterListWriter.toXML().toString()" << std::endl;
   std::cout << xmlprob1 << std::endl;
 
   /* create a input source, parser to read the std::string */
   StringInputSource src(strproblem);
   XMLParser parser(src.stream());
 
   /* parse XML in a std::string */
   XMLObject xmlprob2 = parser.parse();
 
   std::cout << "*** XML from XMLParser.parse()" << std::endl;
   std::cout << xmlprob2 << std::endl;
 
   /* convert the new XML object to a ParameterList */
   XMLParameterListReader pl2xml;
   ParameterList problem2 = pl2xml.toParameterList(xmlprob2);
 
   std::cout << "*** ParameterList from XMLParameterListReader.toParameterList()" << std::endl;
   std::cout << problem2 << std::endl;
 
   /* check that the new parameter list matches the old one */
   TEST_EQUALITY(problem2, problem);
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [10/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Conditions	,
		testConditions
	)

Test all the conditions

Definition at line 54 of file Condition_UnitTests.cpp.

                                                      {
     //Settin up initial list
     RCP<ParameterList> testingList = rcp(new ParameterList("Condition Testing List"));
 
     /*
      * Testing for string condition
      */
     Array<std::string> validValues(tuple<std::string>("mountain dew", "pepsi", "coke", "fanta"));
     RCP<StringValidator> stringVali1 = rcp(new StringValidator(validValues));
 
     testingList->set("string param", "fanta", "parameter for testing string conditions", stringVali1);
 
     StringCondition::ValueList conValues1(tuple<std::string>("pepsi", "coke"));
     RCP<StringCondition> stringCon1 = rcp( new StringCondition(testingList->getEntryRCP("string param"), conValues1));
     TEST_ASSERT(!stringCon1->isConditionTrue());
     testingList->set("string param", "coke");
     TEST_ASSERT(stringCon1->isConditionTrue());
 
     /*
      * Testing for number condition
      */
     testingList->set("double param", 5.0, "parameter for testing number conditions");
 
     RCP<NumberCondition<double> > numberCon1 =
     rcp( new NumberCondition<double>(testingList->getEntryRCP("double param")));
     TEST_ASSERT(numberCon1->isConditionTrue());
     testingList->set("double param", -1.0);
     TEST_ASSERT(!numberCon1->isConditionTrue());
 RCP<SubtractionFunction<double> > doubleTesterFunc = rcp( new SubtractionFunction<double>(100));
     RCP<NumberCondition<double> > numberCon2 =
     rcp( new NumberCondition<double>(testingList->getEntryRCP("double param"), doubleTesterFunc));
     TEST_ASSERT(!numberCon2->isConditionTrue());
     testingList->set("double param", 101.0);
     TEST_ASSERT(numberCon2->isConditionTrue());
 
     /*
      * Testing bool conditions
      */
     testingList->set("bool param", true, "parameter for testing bool conditions");
 
     RCP<BoolCondition> boolCon1 = rcp( new BoolCondition(testingList->getEntryRCP("bool param")));
     TEST_ASSERT(boolCon1->isConditionTrue());
     testingList->set("bool param", false);
     TEST_ASSERT(!boolCon1->isConditionTrue());
 
     /*
      * Test Not condition
      */
     RCP<NotCondition> notCon1 = rcp(new NotCondition(numberCon1));
     TEST_ASSERT(!notCon1->isConditionTrue());
     testingList->set("double param", -1.0);
     TEST_ASSERT(notCon1->isConditionTrue());
 
     /*
      * Test And condition
      */
     Condition::ConstConditionList conList1(tuple<RCP<const Condition> >(stringCon1, boolCon1));
     RCP<AndCondition> andCon1 = rcp(new AndCondition(conList1));
     TEST_ASSERT(!andCon1->isConditionTrue());
     testingList->set("bool param", true);
     TEST_ASSERT(andCon1->isConditionTrue());
 
     /*
      * Testing or condition
      */
     testingList->set("bool param", false);
     RCP<OrCondition> orCon1 = rcp(new OrCondition(conList1));
     TEST_ASSERT(orCon1->isConditionTrue());
     testingList->set("string param", "fanta");
 
     /*
      * Testing equal condition
      */
     RCP<EqualsCondition> equalsCon1 = rcp(new EqualsCondition(conList1));
     TEST_ASSERT(equalsCon1->isConditionTrue());
     testingList->set("bool param", true);
     TEST_ASSERT(!equalsCon1->isConditionTrue());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [11/224]

Teuchos::TEUCHOS_UNIT_TEST	(	XMLParser	,
		orderedWriteRead
	)

Definition at line 55 of file XMLParser_ordered.cpp.

 {
   out << endl;
 
   /* create a ParameterList object */
   string xmlstring1;
   ParameterList wrotepl1("Parent");
   {
     ParameterList c1("Child1");
     ParameterList c2("Child2");
     c1.set("cp1", "first1");
     c1.set("cp2", "second1");
     c2.set("cp3", "first2");
     c2.set("cp4", "second2");
     wrotepl1.set("FirstSublist",c1);
     wrotepl1.set("SecondSublist",c2);
     /* create an XML object from the ParameterList and write it to a string */
     XMLParameterListWriter xml2pl;
     XMLObject xmlprob = xml2pl.toXML(wrotepl1);
     std::ostringstream ss;
     ss << xmlprob;
     xmlstring1 = ss.str();
     out << "*** String 1" << endl;
     out << xmlstring1 << endl;
   }
 
   string xmlstring2;
   ParameterList wrotepl2("Parent");
   {
     ParameterList c1("Child1");
     ParameterList c2("Child2");
     // swap the ordering
     c1.set("cp2", "second1");
     c1.set("cp1", "first1");
     c2.set("cp4", "second2");
     c2.set("cp3", "first2");
     wrotepl2.set("SecondSublist",c2);
     wrotepl2.set("FirstSublist",c1);
     /* create an XML object from the ParameterList and write it to a string */
     XMLParameterListWriter xml2pl;
     XMLObject xmlprob = xml2pl.toXML(wrotepl2);
     std::ostringstream ss;
     ss << xmlprob;
     xmlstring2 = ss.str();
     out << "*** String 2" << endl;
     out << xmlstring2 << endl;
   }
 
   // the different PL orderings should be reflected in the ParameterLists and their XML string representations
   TEST_INEQUALITY(wrotepl1, wrotepl2);
   TEST_INEQUALITY(xmlstring1, xmlstring2);
 
   /* create a input source, parser to read the string */
   ParameterList readpl1, readpl2;
   {
     StringInputSource src(xmlstring1);
     XMLParser parser(src.stream());
     XMLObject xmlprob = parser.parse();
     XMLParameterListReader pl2xml;
     readpl1 = pl2xml.toParameterList(xmlprob);
   }
   {
     StringInputSource src(xmlstring2);
     XMLParser parser(src.stream());
     XMLObject xmlprob = parser.parse();
     XMLParameterListReader pl2xml;
     readpl2 = pl2xml.toParameterList(xmlprob);
   }
 
   /* check that the parameter lists do not match */
   TEST_INEQUALITY(readpl1, readpl2);
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [12/224]

Teuchos::TEUCHOS_UNIT_TEST	(	GetBaseObjVoidPtr	,
		polymorphicClasses
	)

Definition at line 55 of file GetBaseObjVoidPtr_UnitTests.cpp.

 {
   RCP<C> c_ptr(new C);
   RCP<B1> b1_ptr = c_ptr;
   RCP<B2> b2_ptr = c_ptr;
   RCP<A> a_ptr = c_ptr;
   TEST_EQUALITY( getBaseObjVoidPtr(&*c_ptr), static_cast<const void*>(&*c_ptr) );
   TEST_EQUALITY( getBaseObjVoidPtr(&*b1_ptr), static_cast<const void*>(&*c_ptr) );
   TEST_INEQUALITY( static_cast<const void*>(&*b1_ptr), static_cast<const void*>(&*c_ptr) );
   TEST_EQUALITY( getBaseObjVoidPtr(&*b2_ptr), static_cast<const void*>(&*c_ptr) );
   TEST_INEQUALITY( static_cast<const void*>(&*b2_ptr), static_cast<const void*>(&*c_ptr) );
   TEST_EQUALITY( getBaseObjVoidPtr(&*a_ptr), static_cast<const void*>(&*c_ptr) );
   TEST_INEQUALITY( static_cast<const void*>(&*a_ptr), static_cast<const void*>(&*c_ptr) );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [13/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		testValiDeps
	)

Test all the validator dependencies.

Definition at line 55 of file Dependencies_UnitTests.cpp.

                                                      {
     RCP<ParameterList> My_deplist = rcp(new ParameterList);
     RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
 
     /*
      * Testing StringValidatorDependency
      */
     RCP<StringToIntegralParameterEntryValidator<int> >
     stringFoodTypeValidator = rcp(
         new StringToIntegralParameterEntryValidator<int>(
         tuple<std::string>( "Cheese", "Soda", "Chips" )
         ,"Food Type"
         )
     );
 
     RCP<StringToIntegralParameterEntryValidator<int> >
     cheeseValidator = rcp(
         new StringToIntegralParameterEntryValidator<int>(
             tuple<std::string>( "Swiss", "American", "Super Awesome Cheese" )
             ,"Food Selector"
             )
     );
 
     RCP<StringToIntegralParameterEntryValidator<int> >
     sodaValidator = rcp(
         new StringToIntegralParameterEntryValidator<int>(
             tuple<std::string>( "Pepsi", "Coke", "Kurtis Cola", "Bad Cola" )
             ,"Food Selector"
             )
         );
 
     RCP<StringToIntegralParameterEntryValidator<int> >
     chipsValidator = rcp(
         new StringToIntegralParameterEntryValidator<int>(
             tuple<std::string>( "Lays", "Doritos", "Kurtis Super Awesome Brand" )
             ,"Food Selector"
         )
     );
 
     StringValidatorDependency::ValueToValidatorMap testValidatorMap1;
     testValidatorMap1["Cheese"] = cheeseValidator;
     testValidatorMap1["Soda"] = sodaValidator;
     testValidatorMap1["Chips"] = chipsValidator;
 
     ParameterList stringValiDepList = My_deplist->sublist(
     "String Validator Dependency", false,
     "String Validator Dependency testing list.");
     stringValiDepList.set(
     "Food Selector", "Swiss", "select the food you want", cheeseValidator);
     stringValiDepList.set(
     "Food Type",
     "Cheese",
     "String Validator Dependency Tester",
     stringFoodTypeValidator);
 
     RCP<StringValidatorDependency>
     stringValiDep = rcp(
         new StringValidatorDependency(
             stringValiDepList.getEntryRCP("Food Type"),
             stringValiDepList.getEntryRCP("Food Selector"),
             testValidatorMap1,
             cheeseValidator
         )
     );
 
     depSheet1->addDependency(stringValiDep);
     
     TEST_NOTHROW(stringValiDepList.validateParameters(stringValiDepList));
     TEST_ASSERT(depSheet1->hasDependents(
     stringValiDepList.getEntryRCP("Food Type")));
     RCP<const DependencySheet::DepSet> stringValiDepSet =
     depSheet1->getDependenciesForParameter(
       stringValiDepList.getEntryRCP("Food Type"));
     TEST_ASSERT(stringValiDepSet->size() == 1);
     stringValiDepList.set("Food Type","Soda");
     stringValiDep->evaluate();
     TEST_ASSERT(stringValiDepList.getEntry("Food Selector").validator()
     ==
     sodaValidator);
     TEST_THROW(stringValiDepList.validateParameters(stringValiDepList),
     Exceptions::InvalidParameterValue);
     stringValiDepList.set("Food Selector", "Pepsi");
     TEST_NOTHROW(stringValiDepList.validateParameters(stringValiDepList));
 
 
     /*
      * Tesing some different aspects of the StringValidatorDependency
      */
     ParameterList
     stringValiDepList2 = My_deplist->sublist(
         "String Validator Dependency (other validators)",
         false,
         "String validator testing"
     );
 
     RCP<StringToIntegralParameterEntryValidator<int> >
     stringRangeValidator = rcp(
         new StringToIntegralParameterEntryValidator<int>(
         tuple<std::string>( "1-10", "10-33", "50-60" ),
         "Range selector"
         )
     );
 
     RCP<EnhancedNumberValidator<int> > range110Vali =
     rcp(new EnhancedNumberValidator<int>(1,10));
     RCP<EnhancedNumberValidator<int> > range1033Vali =
     rcp(new EnhancedNumberValidator<int>(10,33));
     RCP<EnhancedNumberValidator<int> > range5060Vali =
     rcp(new EnhancedNumberValidator<int>(50,60));
 
     stringValiDepList2.set("Range selector", "1-10",
     "selects the range to validate", stringRangeValidator);
 
     StringValidatorDependency::ValueToValidatorMap rangeValidatorMap1;
     rangeValidatorMap1["1-10"] = range110Vali;
     rangeValidatorMap1["10-33"] = range1033Vali;
     rangeValidatorMap1["50-60"] = range5060Vali;
     stringValiDepList2.set(
     "RangeValue", 3, "the value of the range", range110Vali);
 
     RCP<StringValidatorDependency>
     stringValiDep2 = RCP<StringValidatorDependency>(
         new StringValidatorDependency(
             stringValiDepList2.getEntryRCP("Range selector"),
             stringValiDepList2.getEntryRCP("RangeValue"),
             rangeValidatorMap1,
       range110Vali
         )
     );
 
     depSheet1->addDependency(stringValiDep2);
 
     TEST_NOTHROW(stringValiDepList2.validateParameters(stringValiDepList2));
     TEST_ASSERT(depSheet1->hasDependents(
     stringValiDepList2.getEntryRCP("Range selector")));
     RCP<const DependencySheet::DepSet> stringValiDepSet2 =
     depSheet1->getDependenciesForParameter(
       stringValiDepList2.getEntryRCP("Range selector"));
     TEST_ASSERT(stringValiDepSet2->size() == 1);
     stringValiDepList2.set("Range selector","50-60");
     stringValiDep2->evaluate();
     TEST_ASSERT(stringValiDepList2.getEntry("RangeValue").validator()
     ==
     range5060Vali);
     TEST_THROW(stringValiDepList2.validateParameters(stringValiDepList2),
     Exceptions::InvalidParameterValue);
     stringValiDepList2.set("RangeValue", 55);
     TEST_NOTHROW(stringValiDepList2.validateParameters(stringValiDepList2));
 
     /*
      * Testing the BoolValidatorDependency.
      */
     ParameterList
     boolValidatorDepList = My_deplist->sublist(
         "Bool Validator Dependency List",
         false,
         "Bool Validator Dependency testing list."
     );
 
     boolValidatorDepList.set("Use Validator?",
     true, "truns the validator on and off");
     RCP<EnhancedNumberValidator<int> > basicVali =
     rcp(new EnhancedNumberValidator<int>(1,10));
     RCP<EnhancedNumberValidator<int> > basicVali2 =
     rcp(new EnhancedNumberValidator<int>());
     boolValidatorDepList.set("do I have a validator?",
     4, "does it have a validator?", basicVali);
 
     RCP<BoolValidatorDependency>
     boolValiDep = RCP<BoolValidatorDependency>(
         new BoolValidatorDependency(
             boolValidatorDepList.getEntryRCP("Use Validator?"),
             boolValidatorDepList.getEntryRCP("do I have a validator?"),
             basicVali,
             basicVali2
         )
     );
 
     depSheet1->addDependency(boolValiDep);
 
     TEST_ASSERT(depSheet1->hasDependents(
     boolValidatorDepList.getEntryRCP("Use Validator?")));
     TEST_ASSERT(
     boolValidatorDepList.getEntry("do I have a validator?").validator()
     ==
     basicVali);
     TEST_NOTHROW(
     boolValidatorDepList.validateParameters(boolValidatorDepList));
     RCP<const DependencySheet::DepSet> boolValiDepSet =
     depSheet1->getDependenciesForParameter(boolValidatorDepList.getEntryRCP(
       "Use Validator?"));
     TEST_ASSERT(boolValiDepSet->size() == 1);
     boolValidatorDepList.set("Use Validator?",false);
     boolValiDep->evaluate();
     TEST_ASSERT(
     boolValidatorDepList.getEntry("do I have a validator?").validator()
     ==
     basicVali2);
 
 
     /*
      * Testing the RangeValidatorDependency
      */
     RCP<StringToIntegralParameterEntryValidator<int> >
     lowTempCheeseValidator = rcp(
         new StringToIntegralParameterEntryValidator<int>(
             tuple<std::string>( "PepperJack", "Swiss", "American" ),
             "Cheese to Fondue"
         )
     );
 
     RCP<StringToIntegralParameterEntryValidator<int> >
     highTempCheeseValidator = rcp(
         new StringToIntegralParameterEntryValidator<int>(
             tuple<std::string>(
         "Munster", "Provalone", "Kurtis Super Awesome Cheese"),
             "Cheese to Fondue"
         )
     );
 
     RCP<StringToIntegralParameterEntryValidator<int> >
     defaultCheeseValidator = rcp(
         new StringToIntegralParameterEntryValidator<int>(
             tuple<std::string>(
         "Other cheese", "other cheese 1", "other cheese 3"),
             "Cheese to Fondue"
         )
     );
 
     ParameterList&
     rangeValidatorDepList = My_deplist->sublist(
         "Range Validator Dependency List",
         false,
         "Range Validator Dependency testing list.\nWorking June 27th 2009"
     );
     rangeValidatorDepList.set(
     "Temperature",101.0, "The temperature of the fondue");
     rangeValidatorDepList.set(
     "Cheese to Fondue", "Swiss",
     "The cheese we'll be using in our fondue pot.", lowTempCheeseValidator);
     RangeValidatorDependency<double>::RangeToValidatorMap tempranges;
     tempranges[std::pair<double,double>(100,200)] = lowTempCheeseValidator;
     tempranges[std::pair<double,double>(200,300)] = highTempCheeseValidator;
     RCP<RangeValidatorDependency<double> >
     cheeseTempDep = RCP<RangeValidatorDependency<double> >(
         new RangeValidatorDependency<double>(
             rangeValidatorDepList.getEntryRCP("Temperature"),
             rangeValidatorDepList.getEntryRCP("Cheese to Fondue"),
             tempranges,
       defaultCheeseValidator
         )
     );
     depSheet1->addDependency(cheeseTempDep);
 
     TEST_ASSERT(depSheet1->hasDependents(
     rangeValidatorDepList.getEntryRCP("Temperature")));
     RCP<const DependencySheet::DepSet> rangeValiDepSet =
     depSheet1->getDependenciesForParameter(
       rangeValidatorDepList.getEntryRCP("Temperature"));
     TEST_ASSERT(rangeValiDepSet->size() == 1);
     rangeValidatorDepList.set("Temperature",250.0);
     cheeseTempDep->evaluate();
     TEST_ASSERT(
     rangeValidatorDepList.getEntry("Cheese to Fondue").validator()
     ==
     highTempCheeseValidator);
     TEST_THROW(
     rangeValidatorDepList.validateParameters(rangeValidatorDepList),
     Exceptions::InvalidParameterValue);
     rangeValidatorDepList.set("Cheese to Fondue", "Provalone");
     TEST_NOTHROW(
     rangeValidatorDepList.validateParameters(rangeValidatorDepList));
   rangeValidatorDepList.set("Temperature", 50.0);
   cheeseTempDep->evaluate();
   TEST_ASSERT(
     rangeValidatorDepList.getEntry("Cheese to Fondue").validator()
     ==
     defaultCheeseValidator
   );
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [14/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		DefaultConstruct
	)

Definition at line 56 of file ConstNonconstObjectContainer.cpp.

                                                                     {
   ConstNonconstObjectContainer<std::vector<double> > vectorObj;
   TEST_ASSERT( vectorObj.isConst() == true );
   TEST_ASSERT( vectorObj.getConstObj() == null );
   // This does not throw an exception because the pointer is null
   TEST_ASSERT( vectorObj.getNonconstObj() == null );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [15/224]

Teuchos::TEUCHOS_UNIT_TEST	(	OrdinalIndex	,
		construct
	)

Definition at line 56 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   ECHO(SIOVOCB::OrdinalIndex idx(5));
   TEST_EQUALITY_CONST(idx.idx, 5);
 }

◆ TEUCHOS_UNIT_TEST() [16/224]

Teuchos::TEUCHOS_UNIT_TEST	(	XMLParser	,
		ParseFile
	)

Definition at line 57 of file XMLParser_ParseFileForError.cpp.

   {
     FileInputSource src(filename);
     Teuchos::RCP< Teuchos::XMLInputStream > stream = src.stream();
     while (1) {
       unsigned char c;
       TEUCHOS_TEST_FOR_EXCEPTION( stream->readBytes(&c,1) < 1, std::runtime_error, "Failure reading error message from test file." );
       if (c == '\n') break;
       if (c != '\r') error.push_back(c);
     }
     out << "Expected error string: \"" << error << "\"" << std::endl;
     bool caughtError = false;
     try {
       XMLParser parser(stream);
       parser.parse();
     }
     catch (std::runtime_error &err) {
       std::string what = err.what();
       caughtError = true;
       out << "Caught exception:\n" << what << "\n";
       TEST_INEQUALITY_CONST( what.find(error), std::string::npos );
     }
     TEST_EQUALITY_CONST(caughtError, true);
   }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [17/224]

Teuchos::TEUCHOS_UNIT_TEST	(	XMLParser	,
		IgnoreDeclarations
	)

Definition at line 57 of file XMLParser_ParseWithoutFailing.cpp.

   {
     FileInputSource src(filename);
     Teuchos::RCP< Teuchos::XMLInputStream > stream = src.stream();
     XMLParser parser(stream);
     bool caughtError = false;
     try {
       Teuchos::XMLObject obj = parser.parse();
       out << "Parsed XML object: \n" << obj.toString() << std::endl;
     }
     catch (std::runtime_error &err) {
       caughtError = true;
       out << "XML Parser caught exception:\n" << err.what() << "\n";
     }
     TEST_EQUALITY_CONST(caughtError, false);
   }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [18/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Validators	,
		numberValidators
	)

Tests Number Validators.

Definition at line 57 of file Validator_UnitTest.cpp.

 {
     /*
      * Testing Int Validator.
      */
     RCP<ParameterList> intList =
     rcp(new ParameterList("Int List"));
     RCP<EnhancedNumberValidator<int> > intVali =
     rcp(new EnhancedNumberValidator<int>(0,10,4));
     TEST_ASSERT(intVali->getMin() == 0);
     TEST_ASSERT(intVali->getMax() == 10);
     TEST_ASSERT(intVali->getStep() == 4);
     TEST_ASSERT(intVali->hasMin());
     TEST_ASSERT(intVali->hasMax());
     RCP<EnhancedNumberValidator<int> > intVali2 =
     rcp(new EnhancedNumberValidator<int>());
     TEST_ASSERT(!intVali2->hasMin());
     TEST_ASSERT(!intVali2->hasMax());
     TEST_ASSERT(intVali2->getMin() == std::numeric_limits<int>::min());
     TEST_ASSERT(intVali2->getMax() == std::numeric_limits<int>::max());
     TEST_ASSERT(intVali2->getStep() == EnhancedNumberTraits<int>::defaultStep());
     intList->set("Int Parameter", 5, "int parameter", intVali);
     TEST_NOTHROW(intList->validateParameters(*intList));
     TEST_THROW(intList->set("Int Parameter", 11),
     Exceptions::InvalidParameterValue);
     TEST_THROW(intList->set("Double Parameter", 5.0, "double parameter", intVali),
     Exceptions::InvalidParameterType);
 
   // Test String Conversions with int
   RCP<ParameterList> validList = rcp(new ParameterList("Valid List"));
   RCP<ParameterList> userList = rcp(new ParameterList("User List"));
   TEST_NOTHROW(validList->set("Int Parameter", 4, "int parameter",
     intVali));
 #ifdef HAVE_TEUCHOSCORE_CXX11
   TEST_NOTHROW(userList->set("Int Parameter", "x4"));
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidArgument);
   TEST_NOTHROW(userList->set("Int Parameter", "4x"));
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidArgument);
   TEST_NOTHROW(userList->set("Int Parameter", "12")); // ok string bad range
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidArgument);
 #endif
   userList = rcp(new ParameterList("User List"));
   TEST_NOTHROW(userList->set("Int Parameter", 4));
   TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
   TEST_NOTHROW(userList->set("Int Parameter", "8"));
   TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
   int readInt = userList->getEntry("Int Parameter").getValue<int>(&readInt);
   TEST_ASSERT(readInt == 8);
 
   // check string can generate out of range
   userList = rcp(new ParameterList("User List"));
   TEST_NOTHROW(userList->set("Int Parameter", "20"));
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidParameterType);
 
     /*
      * Testing Short Validator.
      */
     RCP<ParameterList> shortList =
     rcp(new ParameterList("Short List"));
     RCP<EnhancedNumberValidator<short> > shortVali =
     rcp(new EnhancedNumberValidator<short>(0,10,4));
     TEST_ASSERT(shortVali->getMin() == 0);
     TEST_ASSERT(shortVali->getMax() == 10);
     TEST_ASSERT(shortVali->getStep() == 4);
     TEST_ASSERT(shortVali->hasMin());
     TEST_ASSERT(shortVali->hasMax());
     RCP<EnhancedNumberValidator<short> > shortVali2 =
     rcp(new EnhancedNumberValidator<short>());
     TEST_ASSERT(!shortVali2->hasMin());
     TEST_ASSERT(!shortVali2->hasMax());
     TEST_ASSERT(shortVali2->getMin() == std::numeric_limits<short>::min());
     TEST_ASSERT(shortVali2->getMax() == std::numeric_limits<short>::max());
     TEST_ASSERT(shortVali2->getStep() == EnhancedNumberTraits<short>::defaultStep());
     shortList->set("Short Parameter", (short)5, "short parameter", shortVali);
     TEST_NOTHROW(shortList->validateParameters(*shortList));
     TEST_THROW(shortList->set("Short Parameter", (short)11),
     Exceptions::InvalidParameterValue);
     TEST_THROW(shortList->set("Double Parameter", 5.0, "double parameter", shortVali),
     Exceptions::InvalidParameterType);
 
   // Test String Conversions with short
   validList = rcp(new ParameterList("Valid List"));
   userList = rcp(new ParameterList("User List"));
   TEST_NOTHROW(validList->set("Short Parameter", (short)4, "short parameter",
     shortVali));
 #ifdef HAVE_TEUCHOSCORE_CXX11
   TEST_NOTHROW(userList->set("Short Parameter", "x4"));
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidArgument);
   TEST_NOTHROW(userList->set("Short Parameter", "4x"));
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidArgument);
   TEST_NOTHROW(userList->set("Short Parameter", "12")); // ok string bad range
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidArgument);
 #endif
   userList = rcp(new ParameterList("User List"));
   TEST_NOTHROW(userList->set("Short Parameter", (short)4));
   TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
   TEST_NOTHROW(userList->set("Short Parameter", "8"));
   TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
   short readShort = userList->getEntry("Short Parameter").getValue<short>(&readShort);
   TEST_ASSERT(readShort == 8);
 
   // check string can generate out of range
   userList = rcp(new ParameterList("User List"));
   TEST_NOTHROW(userList->set("Short Parameter", "20"));
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidParameterType);
 
     /*
      * Testing Float Validator.
      */
     RCP<ParameterList> floatList = rcp(new ParameterList("Float List"));
     RCP<EnhancedNumberValidator<float> > floatVali =
     rcp(new EnhancedNumberValidator<float>(0,10.0,4.0,6));
     TEST_ASSERT(floatVali->getMin() == 0.0);
     TEST_ASSERT(floatVali->getMax() == 10.0);
     TEST_ASSERT(floatVali->getStep() == 4.0);
     TEST_ASSERT(floatVali->getPrecision() == 6);
     TEST_ASSERT(floatVali->hasMin());
     TEST_ASSERT(floatVali->hasMax());
     RCP<EnhancedNumberValidator<float> > floatVali2 =
     rcp(new EnhancedNumberValidator<float>());
     TEST_ASSERT(!floatVali2->hasMin());
     TEST_ASSERT(!floatVali2->hasMax());
     TEST_ASSERT(floatVali2->getMin() == EnhancedNumberTraits<float>::min());
     TEST_ASSERT(floatVali2->getMax() == EnhancedNumberTraits<float>::max());
     TEST_ASSERT(floatVali2->getStep() == EnhancedNumberTraits<float>::defaultStep());
     TEST_ASSERT(floatVali2->getPrecision() == EnhancedNumberTraits<float>::defaultPrecision());
     floatList->set("Float Parameter", (float)5.0, "float parameter", floatVali);
     TEST_NOTHROW(floatList->validateParameters(*floatList));
     TEST_THROW(floatList->set("Float Parameter", (float)11.0),
     Exceptions::InvalidParameterValue);
     TEST_THROW(floatList->set("Int Parameter", 5, "int parameter", floatVali),
     Exceptions::InvalidParameterType);
 
   // Test String Conversions with float
   validList = rcp(new ParameterList("Valid List"));
   userList = rcp(new ParameterList("User List"));
   TEST_NOTHROW(validList->set("Float Parameter", (float)4.0, "float parameter",
     floatVali));
 #ifdef HAVE_TEUCHOSCORE_CXX11
   TEST_NOTHROW(userList->set("Float Parameter", "x4.0"));
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidArgument);
   TEST_NOTHROW(userList->set("Float Parameter", "4.0x"));
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidArgument);
   TEST_NOTHROW(userList->set("Float Parameter", "12.0")); // ok string bad range
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidArgument);
 #endif
   userList = rcp(new ParameterList("User List"));
   TEST_NOTHROW(userList->set("Float Parameter", (float)8.0));
   TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
   TEST_NOTHROW(userList->set("Float Parameter", "8.0"));
   TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
   float readFloat = userList->getEntry("Float Parameter").getValue<float>(&readFloat);
   TEST_ASSERT(readFloat == 8.0);
 
   // check string can generate out of range
   userList = rcp(new ParameterList("User List"));
   TEST_NOTHROW(userList->set("Float Parameter", "20.0"));
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidParameterType);
 
     /*
      * Testing Double Validator.
      */
     RCP<ParameterList> doubleList = rcp(new ParameterList("Double List"));
     RCP<EnhancedNumberValidator<double> > doubleVali =
     rcp(new EnhancedNumberValidator<double>(0,10.0,4.0,6));
     TEST_ASSERT(doubleVali->getMin() == 0.0);
     TEST_ASSERT(doubleVali->getMax() == 10.0);
     TEST_ASSERT(doubleVali->getStep() == 4.0);
     TEST_ASSERT(doubleVali->getPrecision() == 6);
     TEST_ASSERT(doubleVali->hasMin());
     TEST_ASSERT(doubleVali->hasMax());
     RCP<EnhancedNumberValidator<double> > doubleVali2 =
     rcp(new EnhancedNumberValidator<double>());
     TEST_ASSERT(!doubleVali2->hasMin());
     TEST_ASSERT(!doubleVali2->hasMax());
     TEST_ASSERT(doubleVali2->getMin() == EnhancedNumberTraits<double>::min());
     TEST_ASSERT(doubleVali2->getMax() == EnhancedNumberTraits<double>::max());
     TEST_ASSERT(doubleVali2->getStep() == EnhancedNumberTraits<double>::defaultStep());
     TEST_ASSERT(doubleVali2->getPrecision() == EnhancedNumberTraits<double>::defaultPrecision());
     doubleList->set("Double Parameter", (double)5.0, "double parameter", doubleVali);
     TEST_NOTHROW(doubleList->validateParameters(*doubleList));
     TEST_THROW(doubleList->set("Double Parameter", (double)11.0),
     Exceptions::InvalidParameterValue);
     TEST_THROW(doubleList->set("Int Parameter", 5, "int parameter", doubleVali),
     Exceptions::InvalidParameterType);
 
   // Test String Conversions with double
   validList = rcp(new ParameterList("Valid List"));
   userList = rcp(new ParameterList("User List"));
   TEST_NOTHROW(validList->set("Double Parameter", 4.0, "double parameter",
     doubleVali));
 #ifdef HAVE_TEUCHOSCORE_CXX11
   TEST_NOTHROW(userList->set("Double Parameter", "x4.0"));
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidArgument);
   TEST_NOTHROW(userList->set("Double Parameter", "4.0x"));
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidArgument);
   TEST_NOTHROW(userList->set("Double Parameter", "12.0"));
   TEST_THROW(userList->validateParameters(*validList), // bad range
     Exceptions::InvalidArgument);
 #endif
   userList = rcp(new ParameterList("Valid List"));
   TEST_NOTHROW(userList->set("Double Parameter", 8.0));
   TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
   TEST_NOTHROW(userList->set("Double Parameter", "8.0"));
   TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
   double readDouble = userList->getEntry("Double Parameter").getValue<double>(&readDouble);
   TEST_ASSERT(readDouble == 8.0);
 
   // check string can generate out of range
   userList = rcp(new ParameterList("User List"));
   TEST_NOTHROW(userList->set("Double Parameter", "20.0"));
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidParameterType);
  }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [19/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		ExistingSublistIsOkay
	)

Definition at line 60 of file ParameterList_XMLDuplicateSublists.cpp.

   {
     std::string xmlstring(
         "<ParameterList>                   \n"
         "  <ParameterList name=\"SubList\">\n"
         "  </ParameterList>                \n"
         "</ParameterList>                  \n");
     RCP<ParameterList> plist = getParametersFromXmlString(xmlstring);
     updateParametersFromXmlString( xmlstring, plist() );
   }

◆ TEUCHOS_UNIT_TEST() [20/224]

Teuchos::TEUCHOS_UNIT_TEST	(	UnitTestHarness	,
		nonRootThrowsTeuchosExcept
	)

Definition at line 61 of file UnitTestHarness_Parallel_UnitTests.cpp.

                                                                  {
   out << "Pass on even procs but throws Teuchos exception on other processes!\n";
   const RCP<const Comm<int> > comm = DefaultComm<int>::getComm();
   const int procRank = comm->getRank();
   TEUCHOS_ASSERT_EQUALITY(procRank%2, 0); // Throws on non-root processes
   int myval = 1;
   TEST_EQUALITY_CONST(myval, 1);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [21/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_TwoDArrays	,
		simpleTest
	)

Test all the validator dependencies.

Definition at line 62 of file TwoDArray_UnitTests.cpp.

                                                  {
   TwoDArray<int> simpleArray(3,2);
   simpleArray[0][0] =1;
   simpleArray[0][1] =2;
   simpleArray[1][0] =3;
   simpleArray[1][1] =4;
   simpleArray[2][0] =5;
   simpleArray[2][1] =6;
   TEST_EQUALITY_CONST(simpleArray[0][0],1)
   TEST_EQUALITY_CONST(simpleArray[0][1],2)
   TEST_EQUALITY_CONST(simpleArray[1][0],3)
   TEST_EQUALITY_CONST(simpleArray[1][1],4)
   TEST_EQUALITY_CONST(simpleArray[2][0],5)
   TEST_EQUALITY_CONST(simpleArray[2][1],6)
 
   TEST_EQUALITY_CONST(simpleArray(0,0),1)
   TEST_EQUALITY_CONST(simpleArray(0,1),2)
   TEST_EQUALITY_CONST(simpleArray(1,0),3)
   TEST_EQUALITY_CONST(simpleArray(1,1),4)
   TEST_EQUALITY_CONST(simpleArray(2,0),5)
   TEST_EQUALITY_CONST(simpleArray(2,1),6)
 
   TEST_EQUALITY_CONST(simpleArray.getNumRows(), 3)
   TEST_EQUALITY_CONST(simpleArray.getNumCols(), 2)
   Array<int> oneDArray = tuple<int>(1,2,3,4,5,6);   
   TEST_COMPARE_ARRAYS(oneDArray, simpleArray.getDataArray())
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [22/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Conditions	,
		StringConditionSerialization
	)

Test all the conditions

Definition at line 62 of file Condition_Serialization_UnitTests.cpp.

                                                                    {
   ConditionXMLConverterDB::printKnownConverters(out);
   std::string paramName1 = "string param";
   std::string paramName2 = "string param2";
   std::string dependent1Name = "dependent1";
   std::string dependent2Name = "dependent2";
   std::string paramValue = "cheese";
   StringCondition::ValueList conditionVal1 = tuple<std::string>("steve");
   StringCondition::ValueList conditionVal2 =
     tuple<std::string>("steve", "blah", "your face");
   ParameterList testList("Condition Test List");
   testList.set(paramName1, paramValue);
   testList.set(paramName2, paramValue);
   testList.set(dependent1Name, paramValue);
   testList.set(dependent2Name, paramValue);
   RCP<StringCondition> simpleStringCon =
     rcp(new StringCondition(testList.getEntryRCP(paramName1), conditionVal1));
   RCP<StringCondition> complexStringCon =
     rcp(new StringCondition(
       testList.getEntryRCP(paramName2), conditionVal2));
 
   RCP<ConditionVisualDependency> simpleConDep =
     rcp(new ConditionVisualDependency(
       simpleStringCon,
       testList.getEntryRCP(dependent1Name)));
 
   RCP<ConditionVisualDependency> complexConDep =
     rcp(new ConditionVisualDependency(
       complexStringCon,
       testList.getEntryRCP(dependent2Name)));
 
   RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
   depSheet1->addDependency(simpleConDep);
   depSheet1->addDependency(complexConDep);
 
   writeParameterListToXmlOStream(testList, out, depSheet1);
 
   RCP<DependencySheet> depSheetIn = rcp(new DependencySheet);
   RCP<ParameterList> readinList =
     writeThenReadPL(testList, depSheet1, depSheetIn);
 
   RCP<ParameterEntry> readInDependee1 = readinList->getEntryRCP(paramName1);
   RCP<ParameterEntry> readInDependee2 = readinList->getEntryRCP(paramName2);
 
   RCP<ConditionVisualDependency> simpleReadInDep =
     rcp_dynamic_cast<ConditionVisualDependency>(
       *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()));
   TEST_EQUALITY(
     simpleReadInDep->getCondition()->getTypeAttributeValue(),
     DummyObjectGetter<StringCondition>::getDummyObject()->getTypeAttributeValue());
   RCP<const StringCondition> simpleReadInCon =
     rcp_dynamic_cast<const StringCondition>(simpleReadInDep->getCondition(), true);
   TEST_ASSERT(nonnull(simpleReadInCon));
 
 
   RCP<ConditionVisualDependency> complexReadInDep =
     rcp_dynamic_cast<ConditionVisualDependency>(
       *(depSheetIn->getDependenciesForParameter(readInDependee2)->begin()));
   TEST_EQUALITY(
     complexReadInDep->getCondition()->getTypeAttributeValue(),
     DummyObjectGetter<StringCondition>::getDummyObject()->getTypeAttributeValue());
   RCP<const StringCondition> complexReadInCon =
     rcp_dynamic_cast<const StringCondition>(complexReadInDep->getCondition(), true);
   TEST_ASSERT(nonnull(complexReadInCon));
 
 
   TEST_COMPARE_ARRAYS(
     simpleReadInCon->getValueList(), simpleStringCon->getValueList());
   TEST_COMPARE_ARRAYS(
     complexReadInCon->getValueList(), complexStringCon->getValueList());
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [23/224]

Teuchos::TEUCHOS_UNIT_TEST	(	KeyObjectPair	,
		defaultConstruct
	)

Definition at line 64 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop);
   TEST_EQUALITY_CONST(kop.first, "");
   TEST_EQUALITY_CONST(kop.second.idx, -1);
   TEST_EQUALITY_CONST(kop.isActive(), true);
 }

◆ TEUCHOS_UNIT_TEST() [24/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		NonconstConstruct
	)

Definition at line 65 of file ConstNonconstObjectContainer.cpp.

                                                                      {
   RCP<std::vector<double> > vec = rcp(new std::vector<double> );
   ConstNonconstObjectContainer<std::vector<double> > vectorObj(vec);
   TEST_ASSERT( vectorObj.isConst() == false );
   RCP<const std::vector<double> > vec2 = vectorObj.getConstObj();
   TEST_ASSERT( vec == vec2 );
   RCP<std::vector<double> > vec3 = vectorObj.getNonconstObj();
   TEST_ASSERT( vec == vec3 );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [25/224]

Teuchos::TEUCHOS_UNIT_TEST	(	GetBaseObjVoidPtr	,
		nonPolymorphicClasses
	)

Definition at line 71 of file GetBaseObjVoidPtr_UnitTests.cpp.

 {
   RCP<E> e_ptr(new E);
   RCP<D> d_ptr = e_ptr;
   TEST_EQUALITY( getBaseObjVoidPtr(&*e_ptr), static_cast<const void*>(&*e_ptr) );
   TEST_EQUALITY( getBaseObjVoidPtr(&*d_ptr), static_cast<const void*>(&*e_ptr) );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [26/224]

Teuchos::TEUCHOS_UNIT_TEST	(	UnitTestHarness	,
		nonRootThrowsIntExcept
	)

Definition at line 71 of file UnitTestHarness_Parallel_UnitTests.cpp.

                                                              {
   out << "Pass on even procs but throws int exception on other processes!\n";
   const RCP<const Comm<int> > comm = DefaultComm<int>::getComm();
   const int procRank = comm->getRank();
   if (procRank%2 != 0) {
     throw procRank;
   }
   int myval = 1;
   TEST_EQUALITY_CONST(myval, 1);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [27/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		XMLDuplicatedSublists
	)

Definition at line 71 of file ParameterList_XMLDuplicateSublists.cpp.

   {
     ParameterList pl;
     TEST_THROW( updateParametersFromXmlFile(filename, inOutArg(pl) ), DuplicateParameterSublist );
     TEST_THROW( getParametersFromXmlFile(filename), DuplicateParameterSublist );
     TEST_THROW( getParametersFromXmlFile(filename,null), DuplicateParameterSublist );
     //
     std::ifstream fin(filename.c_str());
     std::string xmlstring( (std::istreambuf_iterator<char>(fin)),
                             std::istreambuf_iterator<char>()      );
     TEST_THROW( updateParametersFromXmlString(xmlstring,inOutArg(pl) ), DuplicateParameterSublist );
     TEST_THROW( getParametersFromXmlString(xmlstring), DuplicateParameterSublist );
     TEST_THROW( getParametersFromXmlString(xmlstring,null), DuplicateParameterSublist );
   }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [28/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ParameterList	,
		ADD_TYPE_AND_ARRAY_TYPE_PARAMETER
	)

Definition at line 71 of file ParameterList_SerializationTest.cpp.

 {
   ParameterList myList;
   ADD_TYPE_AND_ARRAY_TYPE_PARAMETER(int, 2);
   TEST_EQUALITY( getParameter<int>(myList, "int"), 2 );
   TEST_EQUALITY( getParameter<Array<int> >(myList, "int Array"),
     Array<int>(g_arraySize, as<int>(2)) );
   TEST_EQUALITY( getParameter<TwoDArray<int> >(myList, "int 2DArray"),
     TwoDArray<int>(g_arraySize, g_arraySize, as<int>(2)) );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [29/224]

Teuchos::TEUCHOS_UNIT_TEST	(	XMLParameterListHelpers	,
		OverwriteTest
	)

Definition at line 73 of file XMLParameterListHelpers_UnitTest.cpp.

 {
   ParameterList A;  
   A.set("conflicting param","a");
   A.sublist("SublistA").set("param_a", "a");
   A.sublist("SublistA").sublist("SublistB").set("param_b", "b");
   out << "\nA:\n"; A.print(out);
   std::stringstream Astream;  
   writeParameterListToXmlOStream(A,Astream);
 
   // Overwrite
   ParameterList B;
   B.set("conflicting param","b");
   updateParametersFromXmlString(Astream.str(), inoutArg(B),true);
   out << "\nB:\n"; B.print(out);
   TEST_ASSERT( A == B );
   TEST_EQUALITY(getParameter<std::string>(B.sublist("SublistA", true), "param_a"),"a");
   TEST_EQUALITY(getParameter<std::string>(B.sublist("SublistA", true).sublist("SublistB", true), "param_b"),"b");
 
 
   // No Overwrite
   ParameterList C;
   C.set("conflicting param","c");
   updateParametersFromXmlString(Astream.str(), inoutArg(B),false);
   out << "\nC:\n"; C.print(out);
   TEST_ASSERT( C.get("conflicting param","x") == "c" )
   TEST_EQUALITY(getParameter<std::string>(B.sublist("SublistA", true), "param_a"),"a");
   TEST_EQUALITY(getParameter<std::string>(B.sublist("SublistA", true).sublist("SublistB", true), "param_b"),"b");
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [30/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ParameterList	,
		xmlUpdateAndBroadcastNoOverWrite
	)

Definition at line 73 of file ParameterList_UnitTest_Parallel.cpp.

                                                                              {
   const RCP<const Comm<int> > comm = DefaultComm<int>::getComm();
   // Test the broadcast functionality to avoid unscalable I/O collisions
   std::string inputFile="input.xml";
   ParameterList A;
   A.set("Transient",true);
   A.set("Phalanx Graph Visualization Detail",2);
 
   ParameterList B;
   B.set("Transient",true);
   B.set("Phalanx Graph Visualization Detail",2);
 
 
   updateParametersFromXmlFile(inputFile, outArg(A));
   updateParametersFromXmlFileAndBroadcast(inputFile, outArg(B), *comm);
   out << "B = " << B;
   TEST_ASSERT( B.begin() != B.end() ); // Avoid false positive from empty lists
 
   // See if any process returned a failed (i.e. a non-zero local_failed)
   const int local_failed = !(A == B);
   int global_failed = -1;
   reduceAll(*comm, Teuchos::REDUCE_SUM, local_failed, outArg(global_failed));
   TEST_EQUALITY_CONST(global_failed, 0);
 
   // Check the assigned values.
   TEST_EQUALITY( B.get("Transient",false), true)
   TEST_EQUALITY_CONST( B.get("Phalanx Graph Visualization Detail",1), 2)
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [31/224]

Teuchos::TEUCHOS_UNIT_TEST	(	KeyObjectPair	,
		construct_default_isActive
	)

Definition at line 74 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop("key_name1", 7));
   TEST_EQUALITY_CONST(kop.first, "key_name1");
   TEST_EQUALITY_CONST(kop.second.idx, 7);
   TEST_EQUALITY_CONST(kop.isActive(), true);
 }

◆ TEUCHOS_UNIT_TEST() [32/224]

Teuchos::TEUCHOS_UNIT_TEST	(	XMLParameterListHelpers	,
		anonymousParam
	)

Definition at line 75 of file XMLParameterListHelpers_AnonSublists.cpp.

   {
     // one parameter is missing a name; but all parameters are required to have a name
     string anon_param(
       "<ParameterList name=\"Parent\">\n"
       "  <ParameterList>\n"
       "    <Parameter name=\"param_a\" type=\"string\" value=\"a\"/>\n"
       "    <ParameterList>\n"
       "      <Parameter type=\"string\" value=\"b\"/>\n"
       "    </ParameterList>\n"
       "  </ParameterList>\n"
       "</ParameterList>\n");
     StringInputSource src(anon_param);
     XMLParser parser(src.stream());
     XMLObject xmlprob = parser.parse();
     XMLParameterListReader pl2xml;
     ParameterList plTest;
     // this exception name is mis-spelled; oh well
     TEST_THROW( plTest = pl2xml.toParameterList(xmlprob), NoNameAttributeExecption);
   }

◆ TEUCHOS_UNIT_TEST() [33/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		ConstConstruct
	)

Definition at line 76 of file ConstNonconstObjectContainer.cpp.

                                                                  {
   RCP<const std::vector<double> > vec = rcp(new std::vector<double> );
   ConstNonconstObjectContainer<std::vector<double> > vectorObj(vec);
   TEST_ASSERT( vectorObj.isConst() == true );
   RCP<const std::vector<double> > vec2 = vectorObj.getConstObj();
   TEST_ASSERT( vec == vec2 );
   RCP<std::vector<double> > vec3;
   TEST_THROW( vec3 = vectorObj.getNonconstObj(), NonconstAccessError );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [34/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Functions	,
		AdditionTests
	)

Tests for addition functions

Definition at line 78 of file FunctionObject_Serialization_UnitTests.cpp.

                                                    {
   RCP<AdditionFunction<int> > intTester = rcp(
     new AdditionFunction<int>(10));
 
   XMLObject addFuncXML = FunctionObjectXMLConverterDB::convertFunctionObject(
     intTester);
 
   std::string type = addFuncXML.getRequired(
     FunctionObjectXMLConverter::getTypeAttributeName());
   TEST_ASSERT(type == intTester->getTypeAttributeValue() );
   int operand = addFuncXML.getRequired<int>(
     SimpleFunctionXMLConverter<int>::getOperandAttributeName());
   TEST_ASSERT(operand == intTester->getModifiyingOperand());
 
   RCP<FunctionObject> readIn =
     FunctionObjectXMLConverterDB::convertXML(addFuncXML);
   RCP<AdditionFunction<int> > readInCasted =
     rcp_dynamic_cast<AdditionFunction<int> >(readIn);
   TEST_ASSERT(readInCasted.get() != NULL);
   TEST_ASSERT(
     readInCasted->getModifiyingOperand()
     ==
     intTester->getModifiyingOperand());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [35/224]

Teuchos::TEUCHOS_UNIT_TEST	(	GetBaseObjVoidPtr	,
		nonPolymorphicBuiltInTypes
	)

Definition at line 80 of file GetBaseObjVoidPtr_UnitTests.cpp.

 {
   RCP<int> i_ptr(new int);
   TEST_EQUALITY( getBaseObjVoidPtr(&*i_ptr), static_cast<const void*>(&*i_ptr) );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [36/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Validator	,
		exceptionTests
	)

Definition at line 81 of file Validator_SerializationTest.cpp.

 {
   ValidatorXMLConverterDB::printKnownConverters(out);
   out << std::endl;
 
   UNDEFINED_PARAMETERENTRY_VALIDATOR badValidator;
   TEST_THROW(ValidatorXMLConverterDB::getConverter(badValidator), CantFindValidatorConverterException);
 
   TEST_THROW(RCP<ParameterList>
     missingValidatorList = getParametersFromXmlFile("MissingValidator.xml"),
     MissingValidatorDefinitionException);
 
   TEST_THROW(RCP<ParameterList>
     missingPrototypeList = getParametersFromXmlFile("MissingPrototypeValidator.xml"),
         MissingValidatorDefinitionException);
 
   TEST_THROW(RCP<ParameterList>
     conflicitingValiIdsList = getParametersFromXmlFile("ConflictingValidatorIDs.xml"),
     DuplicateValidatorIDsException);
 
   TEST_THROW(RCP<ParameterList>
     stringValidatorBadTagList = getParametersFromXmlFile("StringValidatorBadTag.xml"),
     BadTagException);
 
   TEST_THROW(RCP<ParameterList>
     stringValidatorBadTagList = getParametersFromXmlFile("StringToIntegralValidatorBadTag.xml"),
     BadTagException);
 
   #ifdef HAVE_TEUCHOS_DEBUG
 
   StringValidatorXMLConverter stringConverter;
   AnyNumberValidatorXMLConverter anyNumberConverter;
   ValidatortoIDMap writerDummyMap;
   IDtoValidatorMap readerDummyMap;
   RCP<AnyNumberParameterEntryValidator> anyNumberValidator =
     anyNumberParameterEntryValidator();
   writerDummyMap.insert(anyNumberValidator);
   TEST_THROW(
     stringConverter.fromValidatortoXML(anyNumberValidator, writerDummyMap),
     BadValidatorXMLConverterException);
   XMLObject anyNumberXML =
     anyNumberConverter.fromValidatortoXML(anyNumberValidator, writerDummyMap);
   TEST_THROW(
     stringConverter.fromXMLtoValidator(anyNumberXML, readerDummyMap),
     BadValidatorXMLConverterException);
 
   #endif
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [37/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ParameterList	,
		parameterEntryXMLConverters
	)

Definition at line 82 of file ParameterList_SerializationTest.cpp.

 {
   ParameterList myList;
   ADD_TYPE_AND_ARRAY_TYPE_PARAMETER(int, 2);
   ADD_TYPE_AND_ARRAY_TYPE_PARAMETER(unsigned int, 3);
   ADD_TYPE_AND_ARRAY_TYPE_PARAMETER(short int, 4);
   ADD_TYPE_AND_ARRAY_TYPE_PARAMETER(unsigned short int, 5);
   ADD_TYPE_AND_ARRAY_TYPE_PARAMETER(long int, 6);
   ADD_TYPE_AND_ARRAY_TYPE_PARAMETER(unsigned long int, 7);
   #ifdef HAVE_TEUCHOS_LONG_LONG_INT
   ADD_TYPE_AND_ARRAY_TYPE_PARAMETER(long long int, 8);
   ADD_TYPE_AND_ARRAY_TYPE_PARAMETER(unsigned long long int, 9);
   #endif //HAVE_TEUCHOS_LONG_LONG_INT
   ADD_TYPE_AND_ARRAY_TYPE_PARAMETER(double, 10.0);
   ADD_TYPE_AND_ARRAY_TYPE_PARAMETER(float, 11.0);
 
   ADD_TYPE_AND_ARRAY_TYPE_PARAMETER(std::string, "hello");
 
   ADD_TYPE_PARAMETER(char, 'a');
   ADD_TYPE_PARAMETER(bool, true);
 
   RCP<ParameterList> readInPL = writeThenReadPL(myList);
 
   out << "\nmyList:\n";
   myList.print(out);
   out << "\n*readInPL:\n";
   readInPL->print(out);
 
   TEST_ASSERT(haveSameValues(myList, *readInPL));
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [38/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		default_construct
	)

Definition at line 82 of file FilteredIterator_UnitTests.cpp.

 {
   FilteredIterator<int*, SelectAll<int> > itr;
   // There is just nothing that we can check for an uninitialized iterator!
 }

◆ TEUCHOS_UNIT_TEST() [39/224]

Teuchos::TEUCHOS_UNIT_TEST	(	GlobalMPISession	,
		basic
	)

Definition at line 83 of file GlobalMPISession_UnitTests.cpp.

                                              {
 #ifdef HAVE_MPI
   TEST_ASSERT(GlobalMPISession::mpiIsInitialized());
   int numProcs = -1;
   ECHO(::MPI_Comm_size(MPI_COMM_WORLD, &numProcs));
   TEST_EQUALITY(GlobalMPISession::getNProc(), numProcs);
   int procRank = -1;
   ECHO(::MPI_Comm_rank(MPI_COMM_WORLD, &procRank));
   TEST_EQUALITY(GlobalMPISession::getRank(), procRank);
 #else // HAVE_MPI
   TEST_ASSERT(!GlobalMPISession::mpiIsInitialized());
   TEST_EQUALITY_CONST(GlobalMPISession::getNProc(), 1);
   TEST_EQUALITY_CONST(GlobalMPISession::getRank(), 0);
 #endif // HAVE_MPI
   TEST_ASSERT(!GlobalMPISession::mpiIsFinalized());
   globalReduceSuccess(success, out);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [40/224]

Teuchos::TEUCHOS_UNIT_TEST	(	KeyObjectPair	,
		makeInvalid
	)

Definition at line 84 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop =
     SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex>::makeInvalid());
   TEST_EQUALITY_CONST(kop.first, "");
   TEST_EQUALITY_CONST(kop.second.idx, -1);
   TEST_EQUALITY_CONST(kop.isActive(), false);
 }

◆ TEUCHOS_UNIT_TEST() [41/224]

Teuchos::TEUCHOS_UNIT_TEST	(	XMLParameterListReader	,
		XMLDuplicatedSublistsThrowsError
	)

Definition at line 86 of file ParameterList_XMLDuplicateSublists.cpp.

   {
     FileInputSource xmlFile(filename);
     XMLObject xmlParams = xmlFile.getObject();
     XMLParameterListReader xmlPLReader;
     TEST_EQUALITY_CONST( xmlPLReader.getAllowsDuplicateSublists(), true );
     out << "Changing policy to disallow duplicate sublists" << std::endl;
     xmlPLReader.setAllowsDuplicateSublists( false );
     TEST_EQUALITY_CONST( xmlPLReader.getAllowsDuplicateSublists(), false );
     TEST_THROW( xmlPLReader.toParameterList(xmlParams), DuplicateParameterSublist );
   }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [42/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		NonconstInitialize
	)

Definition at line 87 of file ConstNonconstObjectContainer.cpp.

                                                                      {
   RCP<std::vector<double> > vec = rcp(new std::vector<double> );
   ConstNonconstObjectContainer<std::vector<double> > vectorObj;
   vectorObj.initialize(vec);
   TEST_ASSERT( vectorObj.isConst() == false );
   RCP<const std::vector<double> > vec2 = vectorObj.getConstObj();
   TEST_ASSERT( vec == vec2 );
   RCP<std::vector<double> > vec3 = vectorObj.getNonconstObj();
   TEST_ASSERT( vec == vec3 );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [43/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		construct
	)

Definition at line 89 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::iterator itr_t;
   Array<int> a;
   a.push_back(1);
   FilteredIterator<itr_t,SelectAll<int> > itr(a.begin(), a.begin(), a.end());
   TEST_ITER_EQUALITY(itr.current(), a.begin());
   TEST_ITER_EQUALITY(itr.begin(), a.begin());
   TEST_ITER_EQUALITY(itr.end(), a.end());
   FilteredIterator<itr_t,SelectAll<int> > itr_end(a.end(), a.begin(), a.end());
   TEST_ITER_EQUALITY(itr_end.current(), a.end());
   TEST_ITER_EQUALITY(itr_end.begin(), a.begin());
   TEST_ITER_EQUALITY(itr_end.end(), a.end());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [44/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_TwoDArrays	,
		stringFunctions
	)

Definition at line 91 of file TwoDArray_UnitTests.cpp.

                                                       {
   TwoDArray<int> simpleArray = getSimpleTestTwoDArray();
   std::string stringRep = TwoDArray<int>::toString(simpleArray);
   TwoDArray<int> convertedArray = TwoDArray<int>::fromString(stringRep);
   TEST_EQUALITY(simpleArray, convertedArray)
 
   std::string badStringRep = "4x4:{1.0,1.0}";
   TEST_THROW(TwoDArray<int>::fromString(badStringRep),
     InvalidArrayStringRepresentation)
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [45/224]

Teuchos::TEUCHOS_UNIT_TEST	(	KeyObjectPair	,
		construct_set_isActive
	)

Definition at line 95 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop("key_name2", 8, false));
   TEST_EQUALITY_CONST(kop.first, "key_name2");
   TEST_EQUALITY_CONST(kop.second.idx, 8);
   TEST_EQUALITY_CONST(kop.isActive(), false);
 }

◆ TEUCHOS_UNIT_TEST() [46/224]

Teuchos::TEUCHOS_UNIT_TEST	(	XMLParameterListReader	,
		XMLDuplicatedSublistsBackwardsCompatible
	)

Definition at line 98 of file ParameterList_XMLDuplicateSublists.cpp.

   {
     FileInputSource xmlFile(filename);
     XMLObject xmlParams = xmlFile.getObject();
     XMLParameterListReader xmlPLReader;
     TEST_EQUALITY_CONST( xmlPLReader.getAllowsDuplicateSublists(), true );
     TEST_NOTHROW( xmlPLReader.toParameterList(xmlParams) );
   }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [47/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		ConstInitialize
	)

Definition at line 99 of file ConstNonconstObjectContainer.cpp.

                                                                   {
   RCP<const std::vector<double> > vec = rcp(new std::vector<double> );
   ConstNonconstObjectContainer<std::vector<double> > vectorObj;
   vectorObj.initialize(vec);
   TEST_ASSERT( vectorObj.isConst() == true );
   RCP<const std::vector<double> > vec2 = vectorObj.getConstObj();
   TEST_ASSERT( vec == vec2 );
   RCP<std::vector<double> > vec3;
   TEST_THROW( vec3 = vectorObj.getNonconstObj(), NonconstAccessError );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [48/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_TwoDArrays	,
		emptyTest
	)

Definition at line 102 of file TwoDArray_UnitTests.cpp.

                                                 {
   TwoDArray<int> emptyArray;
   TEST_EQUALITY_CONST(emptyArray.getNumRows(), 0)
   TEST_EQUALITY_CONST(emptyArray.getNumCols(), 0)
   TEST_EQUALITY_CONST(emptyArray.getDataArray().size(), 0)
   TEST_ASSERT(emptyArray.isEmpty());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [49/224]

Teuchos::TEUCHOS_UNIT_TEST	(	GlobalMPISession	,
		barrier
	)

Definition at line 102 of file GlobalMPISession_UnitTests.cpp.

                                                {
   out << "*** Just make sure the basic barrier does not hang or something.\n";
   ECHO(GlobalMPISession::barrier());
   globalReduceSuccess(success, out);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [50/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Functions	,
		MultiplicationTests
	)

Tests for multiplication functions

Definition at line 103 of file FunctionObject_Serialization_UnitTests.cpp.

                                                          {
   RCP<MultiplicationFunction<int> > intTester = rcp(
     new MultiplicationFunction<int>(10));
 
   XMLObject multiFuncXML = FunctionObjectXMLConverterDB::convertFunctionObject(
     intTester);
 
   std::string type = multiFuncXML.getRequired(
     FunctionObjectXMLConverter::getTypeAttributeName());
   TEST_ASSERT(type == intTester->getTypeAttributeValue() );
   int operand = multiFuncXML.getRequired<int>(
     SimpleFunctionXMLConverter<int>::getOperandAttributeName());
   TEST_ASSERT(operand == intTester->getModifiyingOperand());
 
   RCP<FunctionObject> readIn =
     FunctionObjectXMLConverterDB::convertXML(multiFuncXML);
   RCP<MultiplicationFunction<int> > readInCasted =
     rcp_dynamic_cast<MultiplicationFunction<int> >(readIn);
   TEST_ASSERT(readInCasted.get() != NULL);
   TEST_ASSERT(
     readInCasted->getModifiyingOperand()
     ==
     intTester->getModifiyingOperand());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [51/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		deref
	)

Definition at line 105 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::iterator itr_t;
   Array<int> a;
   a.push_back(2);
   FilteredIterator<itr_t,SelectAll<int> > itr(a.begin(), a.begin(), a.end());
   TEST_EQUALITY_CONST(*itr, 2);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [52/224]

Teuchos::TEUCHOS_UNIT_TEST	(	KeyObjectPair	,
		copyConstruct
	)

Definition at line 105 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop1("key_name", 3, false));
   ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop2(kop1));
   TEST_EQUALITY_CONST(kop2.first, "key_name");
   TEST_EQUALITY_CONST(kop2.second.idx, 3);
   TEST_EQUALITY_CONST(kop2.isActive(), false);
 }

◆ TEUCHOS_UNIT_TEST() [53/224]

Teuchos::TEUCHOS_UNIT_TEST	(	GlobalMPISession	,
		sum
	)

Definition at line 109 of file GlobalMPISession_UnitTests.cpp.

                                            {
   ECHO(const int globalSum = GlobalMPISession::sum(GlobalMPISession::getRank()+1));
   ECHO(const int n = GlobalMPISession::getNProc());
   TEST_EQUALITY(globalSum, (n*(n+1))/2);
   globalReduceSuccess(success, out);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [54/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_TwoDArrays	,
		streamTests
	)

Definition at line 110 of file TwoDArray_UnitTests.cpp.

                                                   {
   TwoDArray<int> simpleArray = getSimpleTestTwoDArray();
   std::stringstream ss;
   ss << simpleArray;
   TwoDArray<int> readArray;
   std::istringstream instream(ss.str());
   instream >> readArray;
   TEST_EQUALITY(simpleArray, readArray);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [55/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		AssignmentFromRCP
	)

Definition at line 111 of file ConstNonconstObjectContainer.cpp.

                                                                     {
   RCP<const std::vector<double> > vec = rcp(new std::vector<double> );
   ConstNonconstObjectContainer<std::vector<double> > vectorObj;
   vectorObj = vec;
   TEST_ASSERT( vectorObj.isConst() == true );
   RCP<const std::vector<double> > vec2 = vectorObj.getConstObj();
   TEST_ASSERT( vec == vec2 );
   RCP<std::vector<double> > vec3;
   TEST_THROW( vec3 = vectorObj.getNonconstObj(), NonconstAccessError );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [56/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ParameterList	,
		parameterEntryConverterExceptions
	)

Definition at line 113 of file ParameterList_SerializationTest.cpp.

 {
 
   TEST_THROW(RCP<ParameterList>
     badRootElementList = getParametersFromXmlFile("BadRootElement.xml"),
     BadXMLParameterListRootElementException);
 
   TEST_THROW(RCP<ParameterList>
     badParameterListElementList = getParametersFromXmlFile("BadParameterListElement.xml"),
     BadParameterListElementException);
 
   TEST_THROW(RCP<ParameterList>
     noNameAttributeList = getParametersFromXmlFile("NoNameAttribute.xml"),
     NoNameAttributeExecption);
 
   TEST_THROW(RCP<ParameterList>
     noTypeAttributeList = getParametersFromXmlFile("NoTypeAttribute.xml"),
     NoTypeAttributeExecption);
 
   TEST_THROW(RCP<ParameterList>
     noValueAttributeList = getParametersFromXmlFile("NoValueAttribute.xml"),
     NoValueAttributeExecption);
 
   TEST_THROW(RCP<ParameterList>
     badIdsList = getParametersFromXmlFile("DuplicateParameterIDs.xml"),
     DuplicateParameterIDsException);
 
   TEST_THROW(RCP<ParameterList>
     badParameterEntryConverterList = getParametersFromXmlFile("CantFindParameterEntryConverter.xml"),
       CantFindParameterEntryConverterException);
 
 
   #ifdef HAVE_TEUCHOS_DEBUG
 
   StandardTemplatedParameterConverter<int> intConverter;
   StandardTemplatedParameterConverter<float> floatConverter;
   ValidatortoIDMap dummmyValidatorMap;
   RCP<ParameterEntry> floatParameter = rcp(
     new ParameterEntry((float)3.0));
   TEST_THROW(intConverter.fromParameterEntrytoXML(floatParameter, "blah", 1, dummmyValidatorMap),
     BadParameterEntryXMLConverterTypeException);
 
   XMLObject floatXML = floatConverter.fromParameterEntrytoXML(floatParameter, "float", 1, dummmyValidatorMap);
   TEST_THROW(intConverter.fromXMLtoParameterEntry(floatXML),
     BadParameterEntryXMLConverterTypeException);
 
   #endif
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [57/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		member_access
	)

Definition at line 115 of file FilteredIterator_UnitTests.cpp.

 {
   typedef std::pair<int,int> value_t;
   typedef Array<value_t>::iterator itr_t;
   Array<value_t> a;
   a.push_back(std::make_pair(2, 4));
   FilteredIterator<itr_t,SelectAll<value_t> > itr(a.begin(), a.begin(), a.end());
   TEST_EQUALITY_CONST(itr->first, 2);
   TEST_EQUALITY_CONST(itr->second, 4);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [58/224]

Teuchos::TEUCHOS_UNIT_TEST	(	KeyObjectPair	,
		assign
	)

Definition at line 116 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop1("key_name", 3, false));
   ECHO(SIOVOCB::KeyObjectPair<SIOVOCB::OrdinalIndex> kop2);
   TEST_EQUALITY_CONST(kop2.isActive(), true);
   ECHO(kop2 = kop1);
   TEST_EQUALITY_CONST(kop2.first, "key_name");
   TEST_EQUALITY_CONST(kop2.second.idx, 3);
   TEST_EQUALITY_CONST(kop2.isActive(), false);
 }

◆ TEUCHOS_UNIT_TEST() [59/224]

Teuchos::TEUCHOS_UNIT_TEST	(	GlobalMPISession	,
		allGather
	)

Definition at line 117 of file GlobalMPISession_UnitTests.cpp.

 {
   const int numProcs = GlobalMPISession::getNProc();
   const int procRank = GlobalMPISession::getRank();
   {
     Array<int> allInts;
     ECHO(allInts.resize(numProcs-1));
     TEST_THROW(GlobalMPISession::allGather(procRank+1, allInts()), std::out_of_range);
     ECHO(allInts.resize(numProcs+1));
     TEST_THROW(GlobalMPISession::allGather(procRank+1, allInts()), std::out_of_range);
   }
   {
     Array<int> allInts_expected(numProcs);
     for (int k = 0; k < numProcs; ++k) {
       allInts_expected[k] = k+1;
     }
     Array<int> allInts(numProcs);
     ECHO(GlobalMPISession::allGather(procRank+1, allInts()));
     TEST_EQUALITY(allInts, allInts_expected);
   }
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [60/224]

Teuchos::TEUCHOS_UNIT_TEST	(	RCPNodeHandle	,
		assignSelf
	)

Definition at line 119 of file RCPNodeHandle_UnitTests.cpp.

 {
   RCPNodeHandle nodeRef;
   nodeRef = nodeRef;
 }

◆ TEUCHOS_UNIT_TEST() [61/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_TwoDArray	,
		clearTest
	)

Definition at line 120 of file TwoDArray_UnitTests.cpp.

                                                {
   TwoDArray<int> simpleArray = getSimpleTestTwoDArray();
 
   simpleArray.clear();
   TEST_ASSERT(simpleArray.isEmpty());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [62/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		uninitialize
	)

Definition at line 123 of file ConstNonconstObjectContainer.cpp.

                                                                {
   RCP<const std::vector<double> > vec = rcp(new std::vector<double> );
   ConstNonconstObjectContainer<std::vector<double> > vectorObj(vec);
   TEST_ASSERT( vectorObj.isConst() == true );
   RCP<const std::vector<double> > vec2 = vectorObj.getConstObj();
   TEST_ASSERT( vec == vec2 );
   vectorObj.uninitialize();
   TEST_ASSERT( vectorObj.isConst() == true );
   TEST_ASSERT( vectorObj.getConstObj() == null );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [63/224]

Teuchos::TEUCHOS_UNIT_TEST	(	RCPNodeHandle	,
		defaultConstruct
	)

Definition at line 126 of file RCPNodeHandle_UnitTests.cpp.

 {
   RCPNodeHandle nodeRef;
   TEST_EQUALITY_CONST( nodeRef.count(), 0 );
   TEST_EQUALITY_CONST( nodeRef.has_ownership(), false );
   nodeRef.has_ownership(true);
   TEST_EQUALITY_CONST( nodeRef.has_ownership(), false );
 #ifdef TEUCHOS_DEBUG
   TEST_EQUALITY_CONST( nodeRef.get_base_obj_map_key_void_ptr(), static_cast<void*>(0) );
   TEST_THROW({nodeRef.set_extra_data(any(),"", PRE_DESTROY, true);},
     NullReferenceError);
   TEST_THROW({any &a = nodeRef.get_extra_data("int","blob"); (void)a;},
     NullReferenceError);
   TEST_THROW({const any &a = getConst(nodeRef).get_extra_data("int","blob"); (void)a;},
     NullReferenceError);
   TEST_THROW({any *a = nodeRef.get_optional_extra_data("int","blob"); (void)a;},
     NullReferenceError);
   TEST_THROW({const any *a = getConst(nodeRef).get_optional_extra_data("int","blob"); (void)a;},
     NullReferenceError);
 #endif // TEUCHOS_DEBUG
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [64/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		copy_construct_same
	)

Definition at line 127 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::iterator itr_t;
   Array<int> a;
   a.push_back(1);
   FilteredIterator<itr_t,SelectAll<int> > itr1(a.begin(), a.begin(), a.end());
   FilteredIterator<itr_t,SelectAll<int> > itr2(itr1);
   TEST_ITER_EQUALITY(itr2.current(), a.begin());
   TEST_ITER_EQUALITY(itr2.begin(), a.begin());
   TEST_ITER_EQUALITY(itr2.end(), a.end());
   TEST_EQUALITY(*itr1, *itr2);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [65/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_TwoDArray	,
		resizeTest
	)

Definition at line 127 of file TwoDArray_UnitTests.cpp.

                                                 {
   TwoDArray<int> simpleArray = getSimpleTestTwoDArray();
 
   simpleArray.resizeRows(4);
   TEST_EQUALITY_CONST(simpleArray.getNumRows(), 4);
   TEST_EQUALITY_CONST(simpleArray.getNumCols(), 2);
   TEST_EQUALITY_CONST(simpleArray(3,1), 0);
   TEST_EQUALITY_CONST(simpleArray(1,1), 4);
 
   simpleArray.resizeRows(2);
   TEST_EQUALITY_CONST(simpleArray.getNumRows(), 2);
   TEST_EQUALITY_CONST(simpleArray.getNumCols(), 2);
 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
   TEST_THROW(simpleArray(3,1), RangeError);
 #endif
   TEST_EQUALITY_CONST(simpleArray(1,1), 4);
 
   simpleArray.resizeCols(4);
   TEST_EQUALITY_CONST(simpleArray.getNumCols(), 4);
   TEST_EQUALITY_CONST(simpleArray.getNumRows(), 2);
   TEST_EQUALITY_CONST(simpleArray(1,3), 0);
   TEST_EQUALITY_CONST(simpleArray(1,1), 4);
 
   simpleArray.resizeCols(2);
   TEST_EQUALITY_CONST(simpleArray.getNumCols(), 2);
   TEST_EQUALITY_CONST(simpleArray.getNumRows(), 2);
 #ifdef HAVE_TEUCHOS_ARRAY_BOUNDSCHECK
   TEST_THROW(simpleArray(1,3), RangeError);
 #endif
   TEST_EQUALITY_CONST(simpleArray(1,1), 4);
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [66/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Functions	,
		DivisionTests
	)

Tests for division functions

Definition at line 128 of file FunctionObject_Serialization_UnitTests.cpp.

                                                    {
   RCP<DivisionFunction<int> > intTester = rcp(
     new DivisionFunction<int>(10));
 
   XMLObject divisFuncXML = FunctionObjectXMLConverterDB::convertFunctionObject(
     intTester);
 
   std::string type = divisFuncXML.getRequired(
     FunctionObjectXMLConverter::getTypeAttributeName());
   TEST_ASSERT(type == intTester->getTypeAttributeValue() );
   int operand = divisFuncXML.getRequired<int>(
     SimpleFunctionXMLConverter<int>::getOperandAttributeName());
   TEST_ASSERT(operand == intTester->getModifiyingOperand());
 
   RCP<FunctionObject> readIn =
     FunctionObjectXMLConverterDB::convertXML(divisFuncXML);
   RCP<DivisionFunction<int> > readInCasted =
     rcp_dynamic_cast<DivisionFunction<int> >(readIn);
   TEST_ASSERT(readInCasted.get() != NULL);
   TEST_ASSERT(
     readInCasted->getModifiyingOperand()
     ==
     intTester->getModifiyingOperand());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [67/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		defaultConstruct
	)

Definition at line 129 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   StringIndexedOrderedValueObjectContainer<int> oc;
   TEST_EQUALITY_CONST(oc.numObjects(), 0);
   TEST_EQUALITY_CONST(oc.numStorage(), 0);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [68/224]

Teuchos::TEUCHOS_UNIT_TEST	(	XMLParser	,
		simpleOrderedRead
	)

Definition at line 130 of file XMLParser_ordered.cpp.

 {
 
   /* create a ParameterList object */
   string xmlstring1;
   ParameterList plGold("ParentList");
   {
     ParameterList c1("Z");
     ParameterList c2("A");
     c1.set("A", "first1");
     c1.set("Z", "second1");
     c2.set("Z", "first2");
     c2.set("A", "second2");
     plGold.set("9FirstSublist",c1);
     plGold.set("1SecondSublist",c2);
   }
 
   string xmlsrc(
     "<ParameterList name=\"ParentList\">\n"
     "  <ParameterList name=\"9FirstSublist\">\n"
     "    <Parameter name=\"A\" type=\"string\" value=\"first1\"/>\n"
     "    <Parameter name=\"Z\" type=\"string\" value=\"second1\"/>\n"
     "  </ParameterList>\n"
     "  <ParameterList name=\"1SecondSublist\">\n"
     "    <Parameter name=\"Z\" type=\"string\" value=\"first2\"/>\n"
     "    <Parameter name=\"A\" type=\"string\" value=\"second2\"/>\n"
     "  </ParameterList>\n"
     "</ParameterList>\n");
   ParameterList plTest;
   {
     StringInputSource src(xmlsrc);
     XMLParser parser(src.stream());
     XMLObject xmlprob = parser.parse();
     XMLParameterListReader pl2xml;
     plTest = pl2xml.toParameterList(xmlprob);
   }
 
   TEST_EQUALITY(plTest, plGold);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [69/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Validator	,
		fileNameValidatorConverter
	)

Definition at line 131 of file Validator_SerializationTest.cpp.

 {
   std::string defaultParameterName = "default";
   std::string nonDefaultParameterName = "non default";
 
   RCP<FileNameValidator> defaultValidator =
     rcp(new FileNameValidator);
   RCP<FileNameValidator> nonDefaultValidator =
     rcp(new FileNameValidator(true));
   ParameterList myList("FileName Validator List");
   myList.set("default", "", "parameter for default validator",
     defaultValidator);
   myList.set("non default", "blah.txt", "parameter for non default validator",
     nonDefaultValidator);
 
   RCP<ParameterList> readInPL = writeThenReadPL(myList);
 
   RCP<const FileNameValidator> readinDefault =
     rcp_dynamic_cast<const FileNameValidator>(
       readInPL->getEntry(defaultParameterName).validator(), true);
   TEST_EQUALITY(readinDefault->fileMustExist(), defaultValidator->fileMustExist());
 
   RCP<const FileNameValidator> readinNonDefault =
     rcp_dynamic_cast<const FileNameValidator>(
       readInPL->getEntry(nonDefaultParameterName).validator(), true);
   TEST_EQUALITY(readinNonDefault->fileMustExist(), nonDefaultValidator->fileMustExist());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [70/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Conditions	,
		testConditionGetterAndSetters
	)

Definition at line 134 of file Condition_UnitTests.cpp.

                                                                     {
     //Settin up initial list
     RCP<ParameterList> testingList = rcp(new ParameterList("Condition Testing List"));
 
     Array<std::string> validValues(tuple<std::string>("mountain dew", "pepsi", "coke", "fanta"));
     RCP<StringValidator> stringVali1 = rcp(new StringValidator(validValues));
 
     testingList->set("string param", "fanta", "parameter for testing string conditions", stringVali1);
 
     StringCondition::ValueList conValues1(tuple<std::string>("pepsi", "coke"));
     RCP<StringCondition> stringCon1 = rcp( new StringCondition(testingList->getEntryRCP("string param"), conValues1));
     Dependency::ConstParameterEntryList stringParameters = stringCon1->getAllParameters();
     TEST_ASSERT(stringParameters.size() == 1);
     TEST_ASSERT(stringParameters.find(testingList->getEntryRCP("string param")) != stringParameters.end());
 
     /*
      * Testing for number condition
      */
     testingList->set("double param", 5.0, "parameter for testing number conditions");
 
     RCP<NumberCondition<double> > numberCon1 = rcp( new NumberCondition<double>(testingList->getEntryRCP("double param")));
     Dependency::ConstParameterEntryList numberParameters = numberCon1->getAllParameters();
     TEST_ASSERT(numberParameters.size() == 1);
     TEST_ASSERT(numberParameters.find(testingList->getEntryRCP("double param")) != numberParameters.end());
 
     /*
      * Testing bool conditions
      */
     testingList->set("bool param", true, "parameter for testing bool conditions");
 
     RCP<BoolCondition> boolCon1 = rcp( new BoolCondition(testingList->getEntryRCP("bool param")));
     Dependency::ConstParameterEntryList boolParameters = boolCon1->getAllParameters();
     TEST_ASSERT(boolParameters.size() == 1);
     TEST_ASSERT(boolParameters.find(testingList->getEntryRCP("bool param")) != boolParameters.end());
 
     /*
      * Test Not condition
      */
     RCP<NotCondition> notCon1 = rcp(new NotCondition(numberCon1));
     Dependency::ConstParameterEntryList notParameters = notCon1->getAllParameters();
     TEST_ASSERT(notParameters.size() == 1);
     TEST_ASSERT(notParameters.find(testingList->getEntryRCP("double param")) != notParameters.end());
 
     /*
      * Test And condition
      */
     Condition::ConstConditionList conList1(tuple<RCP<const Condition> >(stringCon1, boolCon1));
     RCP<AndCondition> andCon1 = rcp(new AndCondition(conList1));
     Dependency::ConstParameterEntryList andParameters = andCon1->getAllParameters();
     TEST_ASSERT(andParameters.size() == 2);
     TEST_ASSERT(andParameters.find(testingList->getEntryRCP("string param")) != andParameters.end());
     TEST_ASSERT(andParameters.find(testingList->getEntryRCP("bool param")) != andParameters.end());
 
     /*
      * Testing or condition
      */
     RCP<OrCondition> orCon1 = rcp(new OrCondition(conList1));
     Dependency::ConstParameterEntryList orParameters = orCon1->getAllParameters();
     TEST_ASSERT(orParameters.size() == 2);
     TEST_ASSERT(orParameters.find(testingList->getEntryRCP("string param")) != orParameters.end());
     TEST_ASSERT(orParameters.find(testingList->getEntryRCP("bool param")) != orParameters.end());
 
     /*
      * Testing Equsl condition
      */
     Condition::ConstConditionList conList2(tuple<RCP<const Condition> >(numberCon1, boolCon1));
     RCP<EqualsCondition> equalsCon1 = rcp(new EqualsCondition(conList2));
     Dependency::ConstParameterEntryList equalsParameters = equalsCon1->getAllParameters();
     TEST_ASSERT(equalsParameters.size() == 2);
     TEST_ASSERT(equalsParameters.find(testingList->getEntryRCP("double param")) != equalsParameters.end());
     TEST_ASSERT(equalsParameters.find(testingList->getEntryRCP("bool param")) != equalsParameters.end());
 
     /*
      * Testing BoolLogicCondition add
      */
     equalsCon1->addCondition(orCon1);
     Dependency::ConstParameterEntryList equalsParameters2 = equalsCon1->getAllParameters();
     TEST_ASSERT(equalsParameters2.size() == 3);
     TEST_ASSERT(equalsParameters2.find(testingList->getEntryRCP("string param")) != equalsParameters2.end());
     TEST_ASSERT(equalsParameters2.find(testingList->getEntryRCP("double param")) != equalsParameters2.end());
     TEST_ASSERT(equalsParameters2.find(testingList->getEntryRCP("bool param")) != equalsParameters2.end());
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [71/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		parens
	)

Definition at line 135 of file ConstNonconstObjectContainer.cpp.

                                                           {
   ConstNonconstObjectContainer<std::vector<double> > vectorObj;
   RCP<std::vector<double> > vec = rcp(new std::vector<double>);
   vectorObj.initialize(vec);
   RCP<const std::vector<double> > vec2 = vectorObj();
   TEST_ASSERT( vec == vec2 );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [72/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Conditions	,
		BoolConditionSerialization
	)

Definition at line 135 of file Condition_Serialization_UnitTests.cpp.

                                                                  {
   ConditionXMLConverterDB::printKnownConverters(out);
   std::string paramName1 = "bool param";
   std::string dependent1Name = "dependent1";
   bool paramValue = true;
   std::string dependentValue = "hi there!";
   ParameterList testList("Condition Test List");
   testList.set(paramName1, paramValue);
   testList.set(dependent1Name, dependentValue);
   RCP<BoolCondition> boolCon =
     rcp(new BoolCondition(testList.getEntryRCP(paramName1)));
 
   RCP<ConditionVisualDependency> boolConDep =
     rcp(new ConditionVisualDependency(
       boolCon,
       testList.getEntryRCP(dependent1Name)));
 
   RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
   depSheet1->addDependency(boolConDep);
 
   RCP<DependencySheet> depSheetIn = rcp(new DependencySheet);
   RCP<ParameterList> readinList =
     writeThenReadPL(testList, depSheet1, depSheetIn);
 
   RCP<ParameterEntry> readInDependee1 = readinList->getEntryRCP(paramName1);
 
   RCP<ConditionVisualDependency> simpleReadInDep =
     rcp_dynamic_cast<ConditionVisualDependency>(
       *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()));
   TEST_EQUALITY(
     simpleReadInDep->getCondition()->getTypeAttributeValue(),
     DummyObjectGetter<BoolCondition>::getDummyObject()->getTypeAttributeValue());
   RCP<const BoolCondition> simpleReadInCon =
     rcp_dynamic_cast<const BoolCondition>(simpleReadInDep->getCondition(), true);
   TEST_ASSERT(nonnull(simpleReadInCon));
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [73/224]

Teuchos::TEUCHOS_UNIT_TEST	(	TimeMonitor	,
		FUNC_TIME_MONITOR
	)

Definition at line 137 of file TimeMonitor_UnitTests.cpp.

   {
     using Teuchos::ParameterList;
     using Teuchos::parameterList;
     using Teuchos::RCP;
 
     func_time_monitor1 (); // Function to time.
 
     { // Repeat test for default output format.
       std::ostringstream oss;
       TimeMonitor::summarize (oss);
 
       // Echo summarize() output to the FancyOStream out (which is a
       // standard unit test argument).  Output should only appear in
       // show-all-test-details mode.
       out << oss.str () << std::endl;
 
       // Make sure that the timer's name shows up in the output.
       const size_t substr_i = oss.str ().find ("FUNC_TIME_MONITOR1");
       TEST_INEQUALITY(substr_i, std::string::npos);
     }
 
     { // Repeat test for YAML output, compact style.
       std::ostringstream oss;
       RCP<ParameterList> reportParams =
         parameterList (* (TimeMonitor::getValidReportParameters ()));
       reportParams->set ("Report format", "YAML");
       reportParams->set ("YAML style", "compact");
       TimeMonitor::report (oss, reportParams);
 
       // Echo output to the FancyOStream out (which is a standard unit
       // test argument).  Output should only appear in "show all test
       // details" mode.
       out << oss.str () << std::endl;
 
       // Make sure that the timer's name shows up in the output.
       const size_t substr_i = oss.str ().find ("FUNC_TIME_MONITOR1");
       TEST_INEQUALITY(substr_i, std::string::npos);
     }
 
     { // Repeat test for YAML output, spacious style.
       std::ostringstream oss;
       RCP<ParameterList> reportParams =
         parameterList (* (TimeMonitor::getValidReportParameters ()));
       reportParams->set ("Report format", "YAML");
       reportParams->set ("YAML style", "spacious");
       TimeMonitor::report (oss, reportParams);
 
       // Echo output to the FancyOStream out (which is a standard unit
       // test argument).  Output should only appear in "show all test
       // details" mode.
       out << oss.str () << std::endl;
 
       // Make sure that the timer's name shows up in the output.
       const size_t substr_i = oss.str ().find ("FUNC_TIME_MONITOR1");
       TEST_INEQUALITY(substr_i, std::string::npos);
     }
 
     // This sets up for the next unit test.
     TimeMonitor::clearCounters ();
   }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [74/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		basic_set_get
	)

Definition at line 137 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
 
   //typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB; // unused
   //typedef SIOVOCB::Ordinal Ordinal;
   ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
 
   ECHO(const Ordinal my_int_1_idx1 = oc.setObj("my_int_1", 3));
   TEST_EQUALITY_CONST(my_int_1_idx1, 0);
   TEST_EQUALITY_CONST(oc.numObjects(), 1);
   TEST_EQUALITY_CONST(oc.numStorage(), 1);
   ECHO(const Ordinal my_int_1_idx2 = oc.getObjOrdinalIndex(("my_int_1")));
   TEST_EQUALITY(my_int_1_idx2, my_int_1_idx2);
   TEST_EQUALITY_CONST(*oc.getNonconstObjPtr(my_int_1_idx1), 3);
   TEST_EQUALITY_CONST(*oc.getObjPtr(my_int_1_idx1), 3);
   TEST_EQUALITY_CONST(*oc.getNonconstObjPtr("my_int_1"), 3);
   TEST_EQUALITY_CONST(*oc.getObjPtr("my_int_1"), 3);
 
   ECHO(const Ordinal my_int_2_idx1 = oc.setObj("my_int_2", 4));
   TEST_EQUALITY_CONST(my_int_2_idx1, 1);
   TEST_EQUALITY_CONST(oc.numObjects(), 2);
   TEST_EQUALITY_CONST(oc.numStorage(), 2);
   ECHO(const Ordinal my_int_2_idx2 = oc.getObjOrdinalIndex(("my_int_2")));
   TEST_EQUALITY(my_int_2_idx2, my_int_2_idx2);
   TEST_EQUALITY_CONST(*oc.getNonconstObjPtr(my_int_2_idx1), 4);
   TEST_EQUALITY_CONST(*oc.getObjPtr(my_int_2_idx1), 4);
   TEST_EQUALITY_CONST(*oc.getNonconstObjPtr("my_int_2"), 4);
   TEST_EQUALITY_CONST(*oc.getObjPtr("my_int_2"), 4);
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [75/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		copy_construct_different
	)

Definition at line 141 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::iterator itr_t;
   typedef Array<int>::const_iterator citr_t;
   Array<int> a;
   a.push_back(1);
   FilteredIterator<itr_t,SelectAll<int> > itr1(a.begin(), a.begin(), a.end());
   FilteredIterator<citr_t,SelectAll<int> > itr2(itr1);
   TEST_ITER_EQUALITY(itr2.current(), a.begin());
   TEST_ITER_EQUALITY(itr2.begin(), a.begin());
   TEST_ITER_EQUALITY(itr2.end(), a.end());
   TEST_EQUALITY(*itr1, *itr2);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [76/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		arrow
	)

Definition at line 145 of file ConstNonconstObjectContainer.cpp.

                                                          {
   RCP<std::vector<double> > vec = rcp(new std::vector<double>);
   vec->push_back(25.0);
   vec->push_back(32.0);
   ConstNonconstObjectContainer<std::vector<double> > vectorObj(vec);
   TEST_ASSERT( vectorObj->size() == 2 );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [77/224]

Teuchos::TEUCHOS_UNIT_TEST	(	GlobalMPISession	,
		getArgv
	)

Definition at line 147 of file GlobalMPISession_UnitTests.cpp.

 {
   auto argvCopy = GlobalMPISession::getArgv ();
   const auto numArgs = argvCopy.size ();
   static_assert (std::is_integral<std::decay<decltype (numArgs)>::type>::value,
          "The return type of getArgv has a size() method, "
          "but it does not return an integer.");
   if (numArgs > 0) {
     // This tests that argvCopy has an operator[](int) const.
     const auto arg0 = argvCopy[0];
     static_assert (std::is_convertible<std::decay<decltype (arg0)>::type,
              std::string>::value,
            "The return type of getArgv must have an operator[](int) "
            "that returns a type convertible to std::string.");
   }
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [78/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		SerializationTestMacros
	)

Definition at line 152 of file Dependencies_SerializationTests.cpp.

                                                                 {
   RCP<ParameterEntry> dependee1 = rcp(new ParameterEntry(true));
   RCP<ParameterEntry> dependee2 = rcp(new ParameterEntry(true));
   RCP<ParameterEntry> dependent1 = rcp(new ParameterEntry("blah"));
   RCP<ParameterEntry> dependent2 = rcp(new ParameterEntry("blah"));
   RCP<BoolVisualDependency> simpleDep =
     rcp(new BoolVisualDependency(dependee1, dependent1));
 
 
   Dependency::ParameterEntryList dependentList;
   dependentList.insert(dependent1);
   dependentList.insert(dependent2);
 
   RCP<BoolVisualDependency> complexDep =
     rcp(new BoolVisualDependency(dependee2, dependentList));
 
   BASIC_DEPENDENCY_TEST(simpleDep, BoolVisualDependency, 1, 1);
   VERIFY_DEPENDEE(simpleDep, dependee1);
   VERIFY_DEPENDENT(simpleDep, dependent1);
 
   BASIC_DEPENDENCY_TEST(complexDep, BoolVisualDependency, 1, 2);
   VERIFY_DEPENDEE(complexDep, dependee2);
   VERIFY_DEPENDENT(complexDep, dependent1);
   VERIFY_DEPENDENT(complexDep, dependent2);
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [79/224]

Teuchos::TEUCHOS_UNIT_TEST	(	RCPNodeHandle	,
		add_New_RCPNode_basic
	)

Definition at line 152 of file RCPNodeHandle_UnitTests.cpp.

 {
 
   typedef RCPNodeTracer::RCPNodeStatistics RCPNodeStatistics;
 
   SET_RCPNODE_TRACING();
 
   RCPNode *node = basicRCPNode<A>(true);
 
   const int numActiveNodesBase = RCPNodeTracer::numActiveRCPNodes();
   const RCPNodeStatistics rcpNodeStatisticsBefore = RCPNodeTracer::getRCPNodeStatistics();
 
   out << std::endl;
   ECHO(RCPNodeTracer::addNewRCPNode(node, "dummy"));
 
   out << std::endl;
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase+1);
 
   out << std::endl;
   const RCPNodeStatistics rcpNodeStatistics1 = RCPNodeTracer::getRCPNodeStatistics();
   TEST_COMPARE(rcpNodeStatistics1.maxNumRCPNodes, >=,
     rcpNodeStatisticsBefore.maxNumRCPNodes);
   TEST_EQUALITY(rcpNodeStatistics1.totalNumRCPNodeAllocations,
     rcpNodeStatisticsBefore.totalNumRCPNodeAllocations+1);
   TEST_EQUALITY(rcpNodeStatistics1.totalNumRCPNodeDeletions,
     rcpNodeStatisticsBefore.totalNumRCPNodeDeletions);
 
   out << std::endl;
   ECHO(RCPNodeTracer::removeRCPNode(node));
 
   out << std::endl;
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase);
 
   out << std::endl;
   const RCPNodeStatistics rcpNodeStatistics2 = RCPNodeTracer::getRCPNodeStatistics();
   TEST_COMPARE(rcpNodeStatistics2.maxNumRCPNodes, >=,
     rcpNodeStatisticsBefore.maxNumRCPNodes);
   TEST_EQUALITY(rcpNodeStatistics2.totalNumRCPNodeAllocations,
     rcpNodeStatisticsBefore.totalNumRCPNodeAllocations+1);
   TEST_EQUALITY(rcpNodeStatistics2.totalNumRCPNodeDeletions,
     rcpNodeStatisticsBefore.totalNumRCPNodeDeletions+1);
 
   out << std::endl;
   std::ostringstream statsOut_oss;
   RCPNodeTracer::printRCPNodeStatistics(rcpNodeStatistics2, statsOut_oss);
   std::ostringstream expectedStatsOut_oss;
   expectedStatsOut_oss
     << "\n***"
     << "\n*** RCPNode Tracing statistics:"
     << "\n**\n"
     << "\n    maxNumRCPNodes             = "<<rcpNodeStatistics2.maxNumRCPNodes
     << "\n    totalNumRCPNodeAllocations = "<<rcpNodeStatistics2.totalNumRCPNodeAllocations
     << "\n    totalNumRCPNodeDeletions   = "<<rcpNodeStatistics2.totalNumRCPNodeDeletions
     << "\n";
   TEST_EQUALITY(statsOut_oss.str(), expectedStatsOut_oss.str());
 
   deleteRCPNode(&node);
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [80/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		arrowEmpty
	)

Definition at line 154 of file ConstNonconstObjectContainer.cpp.

                                                               {
   ConstNonconstObjectContainer<std::vector<double> > vectorObj;
 #ifdef TEUCHOS_DEBUG
   TEST_THROW( vectorObj->size(), NullReferenceError );
 #endif
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [81/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		construct_default
	)

Definition at line 155 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
   TEST_EQUALITY_CONST(pl.name(), "ANONYMOUS");
   TEST_EQUALITY_CONST(pl.numParams(), 0);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [82/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		assign_same
	)

Definition at line 156 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::iterator itr_t;
   Array<int> a;
   a.push_back(1);
   FilteredIterator<itr_t,SelectAll<int> > itr1(a.begin(), a.begin(), a.end());
   FilteredIterator<itr_t,SelectAll<int> > itr2;
   itr2 = itr1;
   TEST_ITER_EQUALITY(itr2.current(), a.begin());
   TEST_ITER_EQUALITY(itr2.begin(), a.begin());
   TEST_ITER_EQUALITY(itr2.end(), a.end());
   TEST_EQUALITY(*itr1, *itr2);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [83/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Validator	,
		stringValidatorConverter
	)

Definition at line 160 of file Validator_SerializationTest.cpp.

 {
   std::string defaultParameterName = "default";
   std::string nonDefaultParameterName = "non default";
 
   RCP<StringValidator> nonDefaultValidator = rcp(
     new StringValidator(tuple<std::string>("value1", "cheese", "kurtis", "is", "awesome")));
   ParameterList myList("String Validator List");
   myList.set("non default", "kurtis", "parameter for non default validator",
     nonDefaultValidator);
 
   RCP<ParameterList> readInPL = writeThenReadPL(myList);
 
   RCP<const StringValidator> readinNonDefault =
     rcp_dynamic_cast<const StringValidator>(
       readInPL->getEntry(nonDefaultParameterName).validator(), true);
   TEST_COMPARE_ARRAYS(*(readinNonDefault->validStringValues()),
     *(nonDefaultValidator->validStringValues()));
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [84/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_TwoDArray	,
		symmetryTest
	)

Definition at line 160 of file TwoDArray_UnitTests.cpp.

                                                   {
   TwoDArray<int> simpleArray = getSimpleTestTwoDArray();
   TEST_ASSERT(!simpleArray.isSymmetrical());
   simpleArray.setSymmetrical(true);
   TEST_ASSERT(simpleArray.isSymmetrical());
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [85/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		dereference
	)

Definition at line 163 of file ConstNonconstObjectContainer.cpp.

                                                                {
   RCP<std::vector<double> > vec = rcp(new std::vector<double>);
   vec->push_back(25.0);
   vec->push_back(32.0);
   ConstNonconstObjectContainer<std::vector<double> > vectorObj(vec);
   TEST_ASSERT( (*vectorObj)[0] == 25.0 );
   TEST_ASSERT( (*vectorObj)[1] == 32.0 );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [86/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		construct_withName
	)

Definition at line 163 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl("someName");
   TEST_EQUALITY_CONST(pl.name(), "someName");
   TEST_EQUALITY_CONST(pl.numParams(), 0);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [87/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_TwoDArray	,
		symmetrySerialization
	)

Definition at line 168 of file TwoDArray_UnitTests.cpp.

                                                            {
   TwoDArray<int> simpleArray = getSimpleTestTwoDArray();
   simpleArray.setSymmetrical(true);
   std::string arrayString = TwoDArray<int>::toString(simpleArray);
   TwoDArray<int> readIn = TwoDArray<int>::fromString(arrayString);
   TEST_ASSERT(readIn.isSymmetrical());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [88/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		set_two_keep_ref
	)

Definition at line 169 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   // Test test makes sure that objects keep the same address when adding new
   // objects.
   //typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB; // unused
   //typedef SIOVOCB::Ordinal Ordinal;
   ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
   ECHO(const Ordinal my_int_1_idx = oc.setObj("my_int_1", 3));
   ECHO(const int &my_int_1 = *oc.getObjPtr(my_int_1_idx));
   ECHO(oc.setObj("my_int_2", 4));
   TEST_EQUALITY_CONST(*oc.getObjPtr(my_int_1_idx), 3);
   TEST_EQUALITY(&my_int_1, oc.getObjPtr(my_int_1_idx).get());
   TEST_EQUALITY_CONST(my_int_1, 3);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [89/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		assign_different
	)

Definition at line 171 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::iterator itr_t;
   typedef Array<int>::const_iterator citr_t;
   Array<int> a;
   a.push_back(1);
   FilteredIterator<itr_t,SelectAll<int> > itr1(a.begin(), a.begin(), a.end());
   FilteredIterator<citr_t,SelectAll<int> > itr2;
   itr2 = itr1;
   TEST_ITER_EQUALITY(itr2.current(), a.begin());
   TEST_ITER_EQUALITY(itr2.begin(), a.begin());
   TEST_ITER_EQUALITY(itr2.end(), a.end());
   TEST_EQUALITY(*itr1, *itr2);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [90/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		createParameterList_empty
	)

Definition at line 171 of file ParameterList_UnitTests.cpp.

 {
   RCP<ParameterList> pl = createParameterList();
   TEST_ASSERT(nonnull(pl));
   TEST_EQUALITY_CONST(pl->name(), "ANONYMOUS");
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [91/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		dereferenceEmpty
	)

Definition at line 173 of file ConstNonconstObjectContainer.cpp.

                                                                     {
   ConstNonconstObjectContainer<std::vector<double> > vectorObj;
 #ifdef TEUCHOS_DEBUG
   TEST_THROW( (*vectorObj).size(), NullReferenceError );
 #endif
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [92/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ObjectBuilder	,
		constructor
	)

Definition at line 173 of file ObjectBuilder_UnitTests.cpp.

                                                        {
   RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>();
   TEST_EQUALITY_CONST( ob->getObjectName(), "None" );
   TEST_EQUALITY_CONST( ob->create(), null );
   RCP<const ParameterList> pl;
   TEST_NOTHROW( pl = ob->getValidParameters() );
   TEST_EQUALITY_CONST( pl->get<std::string>("Object Type"), "None" );
   TEST_NOTHROW( ob = null );
 }

◆ TEUCHOS_UNIT_TEST() [93/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		createParameterList_withName
	)

Definition at line 179 of file ParameterList_UnitTests.cpp.

 {
   RCP<ParameterList> pl = createParameterList("dummyName");
   TEST_ASSERT(nonnull(pl));
   TEST_EQUALITY_CONST(pl->name(), "dummyName");
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [94/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		StringVisualDepSerialization
	)

Definition at line 180 of file Dependencies_SerializationTests.cpp.

                                                                      {
   std::string dependee1 = "string param";
   std::string dependee2 = "string param2";
   std::string dependent1 = "dependent param1";
   std::string dependent2 = "dependent param2";
   ParameterList myDepList("String Visual Dep List");
   RCP<DependencySheet> myDepSheet = rcp(new DependencySheet);
   myDepList.set(dependee1, "val1");
   myDepList.set(dependee2, "val2");
   myDepList.set(dependent1, 1.0);
   myDepList.set(dependent2, 1.0);
 
   StringVisualDependency::ValueList valList1 = tuple<std::string>("val1");
 
   RCP<StringVisualDependency> basicStringVisDep = rcp(
     new StringVisualDependency(
       myDepList.getEntryRCP(dependee1),
       myDepList.getEntryRCP(dependent1),
       valList1));
 
   Dependency::ParameterEntryList dependentList;
   dependentList.insert(myDepList.getEntryRCP(dependent1));
   dependentList.insert(myDepList.getEntryRCP(dependent2));
   StringVisualDependency::ValueList valList2 =
     tuple<std::string>("val1", "val2");
 
   RCP<StringVisualDependency> complexStringVisDep = rcp(
     new StringVisualDependency(
       myDepList.getEntryRCP(dependee2),
       dependentList,
       valList2,
       false));
 
   myDepSheet->addDependency(basicStringVisDep);
   myDepSheet->addDependency(complexStringVisDep);
 
   RCP<DependencySheet> readInDepSheet = rcp(new DependencySheet);
 
   XMLParameterListWriter plWriter;
   XMLObject xmlOut = plWriter.toXML(myDepList, myDepSheet);
   out << xmlOut.toString();
 
   RCP<ParameterList> readInList =
     writeThenReadPL(myDepList, myDepSheet, readInDepSheet);
 
   RCP<ParameterEntry> readinDependee1 = readInList->getEntryRCP(dependee1);
   RCP<ParameterEntry> readinDependent1 = readInList->getEntryRCP(dependent1);
   RCP<ParameterEntry> readinDependee2 = readInList->getEntryRCP(dependee2);
   RCP<ParameterEntry> readinDependent2 = readInList->getEntryRCP(dependent2);
 
   RCP<Dependency> readinDep1 =
     *(readInDepSheet->getDependenciesForParameter(readinDependee1)->begin());
 
   RCP<Dependency> readinDep2 =
     *(readInDepSheet->getDependenciesForParameter(readinDependee2)->begin());
 
   BASIC_DEPENDENCY_TEST(readinDep1, StringVisualDependency, 1, 1);
   VERIFY_DEPENDEE(readinDep1, readinDependee1);
   VERIFY_DEPENDENT(readinDep1, readinDependent1);
 
   BASIC_DEPENDENCY_TEST(readinDep2, StringVisualDependency, 1, 2);
   VERIFY_DEPENDEE(readinDep2, readinDependee2);
   VERIFY_DEPENDENT(readinDep2, readinDependent1);
   VERIFY_DEPENDENT(readinDep2, readinDependent2);
 
   RCP<StringVisualDependency> castedDep1 =
     rcp_dynamic_cast<StringVisualDependency>(readinDep1, true);
   RCP<StringVisualDependency> castedDep2 =
     rcp_dynamic_cast<StringVisualDependency>(readinDep2, true);
 
   TEST_COMPARE_ARRAYS(
     castedDep1->getValues(), basicStringVisDep->getValues());
   TEST_COMPARE_ARRAYS(
     castedDep2->getValues(), complexStringVisDep->getValues());
 
   TEST_EQUALITY(castedDep1->getShowIf(), basicStringVisDep->getShowIf());
   TEST_EQUALITY(castedDep2->getShowIf(), complexStringVisDep->getShowIf());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [95/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Validator	,
		boolValidatorConverter
	)

Definition at line 181 of file Validator_SerializationTest.cpp.

 {
   std::string xmlFileName = "BoolValidatorList.xml";
   std::string boolParameterName = "boolParameterName";
   RCP<BoolParameterEntryValidator> boolValidator =
     rcp(new BoolParameterEntryValidator());
 
   ParameterList myList("BoolValidatorList");
   myList.set(boolParameterName, false,
     "A parameter with a BoolParameterEntryValidator validator.",
     boolValidator);
 
   RCP<ParameterList> readInPL = writeThenReadPL(myList);
 
   RCP<const BoolParameterEntryValidator> readInBoolValidator =
     rcp_dynamic_cast<const BoolParameterEntryValidator>(
       readInPL->getEntry(boolParameterName).validator(), true);
 
   // to do - check any stuff we want to check
   // right now it doesn't have any settings
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [96/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		castToRCP
	)

Definition at line 184 of file ConstNonconstObjectContainer.cpp.

                                                              {
   RCP<std::vector<double> > vec = rcp(new std::vector<double>);
   ConstNonconstObjectContainer<std::vector<double> > vectorObj(vec);
   RCP<const std::vector<double> > vec2(vectorObj);
   TEST_ASSERT( vec == vec2 );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [97/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		getObjOrdinalIndex
	)

Definition at line 185 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
 
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   //typedef SIOVOCB::Ordinal Ordinal;
   ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
   ECHO(oc.setObj("my_int_1", 3));
   TEST_EQUALITY_CONST(oc.getObjOrdinalIndex("my_int_1"), 0);
   ECHO(oc.setObj("my_int_2", 3));
   TEST_EQUALITY_CONST(oc.getObjOrdinalIndex("my_int_2"), 1);
   TEST_EQUALITY_CONST(oc.getObjOrdinalIndex("does_not_exist"), SIOVOCB::getInvalidOrdinal());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [98/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ObjectBuilder	,
		setNames
	)

Definition at line 185 of file ObjectBuilder_UnitTests.cpp.

                                                     {
   {
     const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>();
     TEST_THROW( ob->setObjectName(""), std::logic_error );
     TEST_THROW( ob->setObjectTypeName(""), std::logic_error );
   }
   {
     RCP<ObjectBuilder<Foo> > ob;
     TEST_THROW( ob = objectBuilder<Foo>("","Foo Type"), std::logic_error );
     TEST_THROW( ob = objectBuilder<Foo>("Foo",""), std::logic_error );
     TEST_THROW( ob = objectBuilder<Foo>("",""), std::logic_error );
   }
   {
     const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>();
     ob->setObjectName("Foo");
     ob->setObjectTypeName("Foo Type");
     const RCP<const ParameterList> validpl = ob->getValidParameters();
     // Now we check that the parameterlist is correct
     TEST_EQUALITY_CONST( validpl->get<std::string>("Foo Type"), "None" );
     const ParameterEntry pe = validpl->getEntry("Foo Type");
     TEST_EQUALITY_CONST( pe.docString(),
         "Determines the type of Foo object that will be built.\nThe parameters for each Foo Type are specified in this sublist"
         );
   }
   {
     const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>("Foo","Foo Type");
     const RCP<const ParameterList> validpl = ob->getValidParameters();
     // Now we check that the parameterlist is correct
     TEST_EQUALITY_CONST( validpl->get<std::string>("Foo Type"), "None" );
     const ParameterEntry pe = validpl->getEntry("Foo Type");
     TEST_EQUALITY_CONST( pe.docString(),
         "Determines the type of Foo object that will be built.\nThe parameters for each Foo Type are specified in this sublist"
         );
   }
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [99/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		set_get_int
	)

Definition at line 187 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
 
   out << "\n";
   ECHO(pl.set("my int", 3));
 
   out << "\n";
   ECHO(const ParameterEntry& my_int_c_param = getConst(pl).getEntry("my int"));
   TEST_EQUALITY_CONST(my_int_c_param.isUsed(), false);
   TEST_EQUALITY_CONST(my_int_c_param.isList(), false);
   TEST_EQUALITY_CONST(my_int_c_param.isDefault(), false);
   TEST_EQUALITY_CONST(my_int_c_param.docString(), "");
   TEST_ASSERT(is_null(my_int_c_param.validator()));
   TEST_EQUALITY_CONST(getValue<int>(my_int_c_param), 3);
   ECHO(const bool param_isType_int1 = my_int_c_param.isType<int>());
   TEST_EQUALITY_CONST(param_isType_int1, true);
   ECHO(const bool param_isType_double1 = my_int_c_param.isType<double>());
   TEST_EQUALITY_CONST(param_isType_double1, false);
 
   out << "\n";
   ECHO(const ParameterEntry& my_int_param = pl.getEntry("my int"));
   TEST_EQUALITY_CONST(my_int_param.isUsed(), true);
 
   out << "\n";
   ECHO(const int my_int = pl.get<int>("my int"));
   TEST_EQUALITY_CONST(my_int, 3);
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [100/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		equality_operators_same
	)

Definition at line 187 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::iterator itr_t;
   Array<int> a;
   a.push_back(1);
   FilteredIterator<itr_t,SelectAll<int> > itr1(a.begin(), a.begin(), a.end());
   FilteredIterator<itr_t,SelectAll<int> > itr2(itr1);
   TEST_EQUALITY_CONST(itr2 == itr1, true);
   TEST_EQUALITY_CONST(itr2 != itr1, false);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [101/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		castFromRCP
	)

Definition at line 197 of file ConstNonconstObjectContainer.cpp.

                                                                {
   RCP<std::vector<double> > vec = rcp(new std::vector<double>);
   ConstNonconstObjectContainer<std::vector<double> > vectorObj(vec);
   TEST_ASSERT( vectorObj.getConstObj() == vec );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [102/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		equality_operators_different
	)

Definition at line 199 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::iterator itr_t;
   Array<int> a;
   a.push_back(1);
   FilteredIterator<itr_t,SelectAll<int> > itr1(a.begin(), a.begin(), a.end());
   FilteredIterator<itr_t,SelectAll<int> > itr2(a.end(), a.begin(), a.end());
   TEST_EQUALITY_CONST(itr2 == itr1, false);
   TEST_EQUALITY_CONST(itr2 != itr1, true);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [103/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		set_and_set_again
	)

Definition at line 199 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
 
   //typedef StringIndexedOrderedValueObjectContainerBase::Ordinal Ordinal;
   ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
 
   ECHO(const Ordinal my_int_1_idx1 = oc.setObj("my_int_1", 3));
   TEST_EQUALITY_CONST(my_int_1_idx1, 0);
   ECHO(const Ordinal my_int_1_idx2 = oc.getObjOrdinalIndex(("my_int_1")));
   TEST_EQUALITY_CONST(my_int_1_idx2, my_int_1_idx1);
   TEST_EQUALITY_CONST(*oc.getNonconstObjPtr("my_int_1"), 3);
 
   ECHO(const Ordinal my_int_1_idx3 = oc.setObj("my_int_1", 4));
   TEST_EQUALITY_CONST(my_int_1_idx3, 0);
   ECHO(const Ordinal my_int_1_idx4 = oc.getObjOrdinalIndex(("my_int_1")));
   TEST_EQUALITY_CONST(my_int_1_idx3, my_int_1_idx4);
   TEST_EQUALITY_CONST(*oc.getNonconstObjPtr("my_int_1"), 4);
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [104/224]

Teuchos::TEUCHOS_UNIT_TEST	(	TimeMonitor	,
		enableTimer
	)

Definition at line 202 of file TimeMonitor_UnitTests.cpp.

   {
     using Teuchos::Array;
     using Teuchos::OSTab;
     using Teuchos::ParameterList;
     using Teuchos::parameterList;
     using Teuchos::RCP;
     using Teuchos::rcpFromRef;
     using Teuchos::Time;
     using Teuchos::TimeMonitor;
     using std::endl;
     typedef Teuchos::Array<RCP<Time> >::size_type size_type;
 
     out << "Testing TimeMonitor's disableTimer() and enableTimer() methods"
         << endl;
     OSTab (rcpFromRef (out));
 
     out << "Creating timers" << endl;
     const int numTrials = 5;
     const int numTimers = 3;
     Array<RCP<Time> > timers (numTimers);
     for (size_type i = 0; i < numTimers; ++i) {
       std::ostringstream os; // construct timer name
       os << "Timer " << i;
       timers[i] = TimeMonitor::getNewTimer (os.str ());
     }
 
     out << "Running all timers without disabling any" << endl;
     // The actual number of operations in slowloop is proportional to
     // the cube of the loop length.  Adjust loopLength as necessary to
     // ensure the timer reports a nonzero elapsed time for each of the
     // invocations.
     const size_t loopLength = 25;
     for (int k = 0; k < numTrials; ++k) {
       for (size_type i = 0; i < numTimers; ++i) {
         TimeMonitor timeMon (* timers[i]);
         slowLoop (loopLength);
       }
     }
     for (size_type i = 0; i < numTimers; ++i) {
       TEST_EQUALITY( timers[i]->numCalls(), numTrials );
     }
 
     out << "Disabling one timer and trying again" << endl;
     // Disable timers[0] only, and repeat the above loops.
     TEST_NOTHROW( TimeMonitor::disableTimer ("Timer 0") );
     for (int k = 0; k < numTrials; ++k) {
       for (size_type i = 0; i < numTimers; ++i) {
         TimeMonitor timeMon (* timers[i]);
         slowLoop (loopLength);
       }
     }
     TEST_EQUALITY( timers[0]->numCalls(), numTrials );
     for (size_type i = 1; i < numTimers; ++i) {
       TEST_EQUALITY( timers[i]->numCalls(), 2*numTrials );
     }
 
     out << "Reenabling the timer and trying again" << endl;
     // Enable timers[0] and repeat the above loops.
     TEST_NOTHROW( TimeMonitor::enableTimer ("Timer 0") );
     for (int k = 0; k < numTrials; ++k) {
       for (size_type i = 0; i < numTimers; ++i) {
         TimeMonitor timeMon (* timers[i]);
         slowLoop (loopLength);
       }
     }
     TEST_EQUALITY( timers[0]->numCalls(), 2*numTrials );
     for (size_type i = 1; i < numTimers; ++i) {
       TEST_EQUALITY( timers[i]->numCalls(), 3*numTrials );
     }
 
     out << "Test that summarize() reports enabled and disabled timers" << endl;
     // Make sure that summarize() reports all timers.  Disabling a
     // timer must _not_ exclude it from the list of timers printed by
     // summarize().  Disable a different timer this time just for fun.
     TEST_NOTHROW( TimeMonitor::disableTimer ("Timer 1") );
     {
       std::ostringstream oss;
       TimeMonitor::summarize (oss);
 
       // Echo summarize() output to the FancyOStream out (which is a
       // standard unit test argument).  Output should only appear in
       // show-all-test-details mode.
       out << oss.str () << std::endl;
 
       // Make sure that each timer's name shows up in the output.
       for (size_type i = 0; i < numTimers; ++i) {
         const std::string name = timers[i]->name ();
         const size_t substr_i = oss.str ().find (name);
         TEST_INEQUALITY(substr_i, std::string::npos);
       }
     }
 
     // This sets up for the next unit test.
     TimeMonitor::clearCounters ();
   }

◆ TEUCHOS_UNIT_TEST() [105/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Validator	,
		anynumberValidatorConverter
	)

Definition at line 203 of file Validator_SerializationTest.cpp.

 {
   std::string xmlFileName = "AnyNumberValidatorList.xml";
   std::string defaultParameterName = "default";
   std::string nonDefaultParameterName = "preferred and accepted";
   RCP<AnyNumberParameterEntryValidator> defaultValidator =
     rcp(new AnyNumberParameterEntryValidator());
   AnyNumberParameterEntryValidator::AcceptedTypes acceptedTypes;
   acceptedTypes.allowDouble(false);
   RCP<AnyNumberParameterEntryValidator> nonDefaultValidator =
     rcp(
       new AnyNumberParameterEntryValidator(
         AnyNumberParameterEntryValidator::PREFER_INT,
         acceptedTypes
         )
       );
 
   ParameterList myList("AnyNumberValidatorList");
   myList.set(defaultParameterName, 10.0,
     "A parameter with the default AnyNumberValidator on it", defaultValidator);
   myList.set(nonDefaultParameterName, 1,
     "A prameter with an AnyNumberValidator on it that has the preferred and accepted types differnet from the default",
     nonDefaultValidator);
 
   RCP<ParameterList> readInPL = writeThenReadPL(myList);
 
   RCP<const AnyNumberParameterEntryValidator> readinDefaultValidator =
     rcp_dynamic_cast<const AnyNumberParameterEntryValidator>(
       readInPL->getEntry(defaultParameterName).validator(), true);
   TEST_EQUALITY(readinDefaultValidator->isDoubleAllowed(),
     defaultValidator->isDoubleAllowed());
   TEST_EQUALITY(readinDefaultValidator->isIntAllowed(),
     defaultValidator->isIntAllowed());
   TEST_EQUALITY(readinDefaultValidator->isStringAllowed(),
     defaultValidator->isStringAllowed());
   TEST_EQUALITY(readinDefaultValidator->getPreferredType(),
     defaultValidator->getPreferredType());
 
   RCP<const AnyNumberParameterEntryValidator> readinNonDefaultValidator =
     rcp_dynamic_cast<const AnyNumberParameterEntryValidator>(
       readInPL->getEntry(nonDefaultParameterName).validator(), true);
   TEST_EQUALITY(readinNonDefaultValidator->isDoubleAllowed(),
     nonDefaultValidator->isDoubleAllowed());
   TEST_EQUALITY(readinNonDefaultValidator->isIntAllowed(),
     nonDefaultValidator->isIntAllowed());
   TEST_EQUALITY(readinNonDefaultValidator->isStringAllowed(),
     nonDefaultValidator->isStringAllowed());
   TEST_EQUALITY(readinNonDefaultValidator->getPreferredType(),
     nonDefaultValidator->getPreferredType());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [106/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		is_null
	)

Definition at line 204 of file ConstNonconstObjectContainer.cpp.

                                                            {
   ConstNonconstObjectContainer<std::vector<double> > vectorObj;
   TEST_ASSERT( is_null(vectorObj) );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [107/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ConstNonconstObjectContainer	,
		nonnull
	)

Definition at line 210 of file ConstNonconstObjectContainer.cpp.

                                                            {
   RCP<std::vector<double> > vec = rcp(new std::vector<double>);
   ConstNonconstObjectContainer<std::vector<double> > vectorObj(vec);
   TEST_ASSERT( nonnull(vectorObj) );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [108/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		pre_iterate_forward_no_filtering
	)

Definition at line 211 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::const_iterator citr_t;
   Array<int> a = tuple<int>(1, 2, 3);
   FilteredIterator<citr_t,SelectAll<int> > itr(a.begin(), a.begin(), a.end());
   FilteredIterator<citr_t,SelectAll<int> > itr_end(a.end(), a.begin(), a.end());
   TEST_ITER_INEQUALITY(itr, itr_end);
   TEST_EQUALITY_CONST(*itr, 1);
   ECHO(++itr);
   TEST_EQUALITY_CONST(*itr, 2);
   ECHO(++itr);
   TEST_EQUALITY_CONST(*itr, 3);
   ECHO(++itr);
   TEST_ITER_EQUALITY(itr, itr_end);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [109/224]

Teuchos::TEUCHOS_UNIT_TEST	(	RCPNodeHandle	,
		add_New_RCPNode_add_owning_twice_error
	)

Definition at line 213 of file RCPNodeHandle_UnitTests.cpp.

 {
   SET_RCPNODE_TRACING();
 #ifdef HAVE_TEUCHOS_STACKTRACE
   // Make sure that you store a stacktrace so as not to affect the RCPNode count below!
   Teuchos::store_stacktrace();
 #endif
   A *a_ptr = new A;
   RCPNode *node1 = basicRCPNodeNoAlloc<A>(a_ptr, true);
   const int numActiveNodesBase = RCPNodeTracer::numActiveRCPNodes();
   ECHO(RCPNodeTracer::addNewRCPNode(node1, "dummy1"));
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase+1);
   RCPNode *node2 = basicRCPNodeNoAlloc<A>(a_ptr, true);
   TEST_THROW(RCPNodeTracer::addNewRCPNode(node2, "dummy2"), DuplicateOwningRCPError);
   ECHO(RCPNodeTracer::removeRCPNode(node1));
   deleteRCPNode(&node1);
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase);
   node2->has_ownership(false);
   deleteRCPNode(&node2);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [110/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		param_isParameter_isSublist_isType
	)

Definition at line 218 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
   ECHO(pl.set("my int", 3));
   ECHO(const int my_int = pl.get<int>("my int"));
   TEST_EQUALITY_CONST(my_int, 3);
   TEST_EQUALITY_CONST(pl.isParameter("my int"), true);
   TEST_EQUALITY_CONST(pl.isParameter("Does not Exist"), false);
   TEST_EQUALITY_CONST(pl.isSublist("my int"), false);
   TEST_EQUALITY_CONST(pl.isSublist("Does not exist"), false);
   TEST_EQUALITY_CONST(pl.isType<int>("my int"), true);
   TEST_EQUALITY_CONST(pl.isType<double>("my int"), false);
   TEST_EQUALITY_CONST(pl.isType("my int", static_cast<int*>(0)), true);
   TEST_EQUALITY_CONST(pl.isType("my int", static_cast<double*>(0)), false);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [111/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Conditions	,
		testConditionException
	)

Definition at line 219 of file Condition_UnitTests.cpp.

                                                              {
     //Settin up initial list
     RCP<ParameterList> testingList = rcp(new ParameterList("Condition Testing List"));
     testingList->set("double param",1.0);
     testingList->set("string param", "awesome");
     RCP<ParameterList> testingList2 = rcp(new ParameterList("Condition Testing List"));
     testingList2->set("bool param", true);
 
     TEST_THROW(BoolCondition boolCon1(testingList->getEntryRCP("bool param")), InvalidConditionException);
     TEST_THROW(StringCondition stringCon1(testingList->getEntryRCP("double param"), "coke"), InvalidConditionException);
     TEST_THROW(BoolCondition boolCon1(testingList->getEntryRCP("double param")), InvalidConditionException);
     Condition::ConstConditionList conList1;
     TEST_THROW(AndCondition andCon1(conList1), InvalidConditionException);
     RCP<const Condition> con1;
     TEST_THROW(NotCondition notCon1(con1), InvalidConditionException);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [112/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		basicNonconstIterators
	)

Definition at line 220 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainer<int>::Iterator Iterator;
   ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
   ECHO(oc.setObj("c", 1));
   ECHO(oc.setObj("a", 2));
   ECHO(oc.setObj("b", 3));
   ECHO(Iterator itr = oc.nonconstBegin());
   TEST_EQUALITY_CONST(itr->first, "c");
   TEST_EQUALITY_CONST(itr->second, 1);
   ECHO(itr->second = 5);
   TEST_EQUALITY_CONST(itr->second, 5);
   ECHO(++itr);
   TEST_EQUALITY_CONST(itr->first, "a");
   TEST_EQUALITY_CONST(itr->second, 2);
   ECHO(itr->second = 6);
   TEST_EQUALITY_CONST(itr->second, 6);
   ECHO(++itr);
   TEST_EQUALITY_CONST(itr->first, "b");
   TEST_EQUALITY_CONST(itr->second, 3);
   ECHO(itr->second = 7);
   TEST_EQUALITY_CONST(itr->second, 7);
   ECHO(++itr);
   TEST_ITER_EQUALITY(itr, oc.nonconstEnd());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [113/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		post_iterate_forward_no_filtering
	)

Definition at line 228 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::const_iterator citr_t;
   Array<int> a = tuple<int>(1, 2, 3);
   FilteredIterator<citr_t,SelectAll<int> > itr(a.begin(), a.begin(), a.end());
   FilteredIterator<citr_t,SelectAll<int> > itr_end(a.end(), a.begin(), a.end());
   TEST_ITER_INEQUALITY(itr, itr_end);
   ECHO(const int v0 = *itr++);
   TEST_EQUALITY_CONST(v0, 1);
   ECHO(const int v1 = *itr++);
   TEST_EQUALITY_CONST(v1, 2);
   ECHO(const int v2 = *itr++);
   TEST_EQUALITY_CONST(v2, 3);
   TEST_ITER_EQUALITY(itr, itr_end);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [114/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ObjectBuilder	,
		setObjectFactory
	)

Definition at line 233 of file ObjectBuilder_UnitTests.cpp.

                                                             {
   const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>("Foo","Foo Type");
   TEST_EQUALITY_CONST( ob->getObjectName(), "None" );
   ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
   TEST_EQUALITY_CONST( ob->getObjectName(), "Foo A" );  // 3.
   RCP<const ParameterList> pl = ob->getValidParameters();
   TEST_EQUALITY_CONST( pl->get<std::string>("Foo Type"), "Foo A" ); // 1.
   TEST_EQUALITY_CONST( pl->sublist("Foo A").get<std::string>("String"), "A" ); // 1.
   const RCP<Foo> foo = ob->create();
   const RCP<FooA> fooA = rcp_dynamic_cast<FooA>(foo,false);
   TEST_EQUALITY_CONST( is_null(fooA), false ); // 2.
   ob->setObjectFactory(abstractFactoryStd<Foo,FooB>(),"Foo B");
   pl = ob->getValidParameters();
   TEST_EQUALITY_CONST( pl->get<std::string>("Foo Type"), "Foo B" ); // 4.
   TEST_THROW( ob->setObjectFactory(abstractFactoryStd<Foo,FooC>(),""), std::logic_error ); // 1a.
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [115/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		sublist_isParameter_isSublist_isType
	)

Definition at line 235 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
   ECHO(pl.sublist("my sublist").set("my int", 3));
   ECHO(const int my_int = getConst(pl).sublist("my sublist").get<int>("my int"));
   TEST_EQUALITY_CONST(my_int, 3);
   TEST_EQUALITY_CONST(pl.isParameter("my sublist"), true); // Should be false, but backward compatiable!
   TEST_EQUALITY_CONST(pl.isParameter("Does not Exist"), false);
   TEST_EQUALITY_CONST(pl.isSublist("my sublist"), true);
   TEST_EQUALITY_CONST(pl.isType<ParameterList>("my sublist"), true);
   TEST_EQUALITY_CONST(pl.isType<double>("my sublist"), false);
   TEST_EQUALITY_CONST(pl.isType("my sublist", static_cast<ParameterList*>(0)), true);
   TEST_EQUALITY_CONST(pl.isType("my sublist", static_cast<double*>(0)), false);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [116/224]

Teuchos::TEUCHOS_UNIT_TEST	(	RCPNodeHandle	,
		add_New_RCPNode_add_nonowning_twice_okay_1
	)

Definition at line 235 of file RCPNodeHandle_UnitTests.cpp.

 {
   SET_RCPNODE_TRACING();
   A *a_ptr = new A;
   RCPNode *node1 = basicRCPNodeNoAlloc<A>(a_ptr, true);
   const int numActiveNodesBase = RCPNodeTracer::numActiveRCPNodes();
   ECHO(RCPNodeTracer::addNewRCPNode(node1, "dummy1"));
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase+1);
   RCPNode *node2 = basicRCPNodeNoAlloc<A>(a_ptr, false);
   ECHO(RCPNodeTracer::addNewRCPNode(node2, "dummy2"));
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase+2);
   TEST_EQUALITY(RCPNodeTracer::getExistingRCPNode(a_ptr), node1);
   ECHO(RCPNodeTracer::removeRCPNode(node2));
   deleteRCPNode(&node2);
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase+1);
   ECHO(RCPNodeTracer::removeRCPNode(node1));
   deleteRCPNode(&node1);
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [117/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		pre_iterate_backward_no_filtering
	)

Definition at line 245 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::const_iterator citr_t;
   Array<int> a = tuple<int>(1, 2, 3);
   FilteredIterator<citr_t,SelectAll<int> > itr(a.end(), a.begin(), a.end());
   FilteredIterator<citr_t,SelectAll<int> > itr_begin(a.begin(), a.begin(), a.end());
   ECHO(--itr);
   TEST_EQUALITY_CONST(*itr, 3);
   ECHO(--itr);
   TEST_EQUALITY_CONST(*itr, 2);
   ECHO(--itr);
   TEST_EQUALITY_CONST(*itr, 1);
   TEST_ITER_EQUALITY(itr, itr_begin);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [118/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		basicConstIterators
	)

Definition at line 247 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
  typedef StringIndexedOrderedValueObjectContainer<int>::ConstIterator ConstIterator;
   ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
   ECHO(oc.setObj("c", 1));
   ECHO(oc.setObj("a", 2));
   ECHO(oc.setObj("b", 3));
   ECHO(ConstIterator itr = oc.begin());
   TEST_EQUALITY_CONST(itr->first, "c");
   TEST_EQUALITY_CONST(itr->second, 1);
   ECHO(++itr);
   TEST_EQUALITY_CONST(itr->first, "a");
   TEST_EQUALITY_CONST(itr->second, 2);
   ECHO(++itr);
   TEST_EQUALITY_CONST(itr->first, "b");
   TEST_EQUALITY_CONST(itr->second, 3);
   ECHO(++itr);
   TEST_ITER_EQUALITY(itr, oc.end());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [119/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ObjectBuilder	,
		setObjectFactory_bad
	)

Definition at line 251 of file ObjectBuilder_UnitTests.cpp.

                                                                  {
   {
     const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>("Foo","Foo Type");
     ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
     // ObjectBuilder will let you add the object, but will not throw until getValidParameters is called
 #ifdef TEUCHOS_DEBUG
     TEST_THROW( ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A"), std::logic_error );
 #else // TEUCHOS_DEBUG
     TEST_NOTHROW( ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A") );
     TEST_THROW( ob->getValidParameters(), std::logic_error );
 #endif // TEUCHOS_DEBUG
   }
   {
     const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>("Foo","Foo Type");
     ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
     TEST_NOTHROW( ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"New Foo A") );
     TEST_NOTHROW( ob->getValidParameters() );
   }
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [120/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		set_doc
	)

Definition at line 251 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
   ECHO(pl.set("my int", 3, "Some documentation"));
   ECHO(const ParameterEntry& my_int_param = getConst(pl).getEntry("my int"));
   TEST_EQUALITY_CONST(my_int_param.docString(), "Some documentation");
   TEST_ASSERT(is_null(my_int_param.validator()));
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [121/224]

Teuchos::TEUCHOS_UNIT_TEST	(	RCPNodeHandle	,
		add_New_RCPNode_add_nonowning_twice_okay_2
	)

Definition at line 256 of file RCPNodeHandle_UnitTests.cpp.

 {
   SET_RCPNODE_TRACING();
   A *a_ptr = new A;
   RCPNode *node1 = basicRCPNodeNoAlloc<A>(a_ptr, false);
   const int numActiveNodesBase = RCPNodeTracer::numActiveRCPNodes();
   ECHO(RCPNodeTracer::addNewRCPNode(node1, "dummy1"));
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase+1);
   RCPNode *node2 = basicRCPNodeNoAlloc<A>(a_ptr, true);
   ECHO(RCPNodeTracer::addNewRCPNode(node2, "dummy2"));
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase+2);
   TEST_EQUALITY(RCPNodeTracer::getExistingRCPNode(a_ptr), node2);
   ECHO(RCPNodeTracer::removeRCPNode(node2));
   deleteRCPNode(&node2);
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase+1);
   ECHO(RCPNodeTracer::removeRCPNode(node1));
   deleteRCPNode(&node1);
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [122/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		BoolVisualDepSerialization
	)

Definition at line 259 of file Dependencies_SerializationTests.cpp.

                                                                    {
   std::string dependee1 = "bool param";
   std::string dependee2 = "bool param2";
   std::string dependent1 = "dependent param1";
   std::string dependent2 = "dependent param2";
   ParameterList myDepList("Bool Visual Dep List");
   RCP<DependencySheet> myDepSheet = rcp(new DependencySheet);
   myDepList.set(dependee1, true);
   myDepList.set(dependee2, true);
   myDepList.set(dependent1, 1.0);
   myDepList.set(dependent2, 1.0);
 
   RCP<BoolVisualDependency> trueBoolVisDep = rcp(
     new BoolVisualDependency(
       myDepList.getEntryRCP(dependee1),
       myDepList.getEntryRCP(dependent1)));
 
   Dependency::ParameterEntryList dependentList;
   dependentList.insert(myDepList.getEntryRCP(dependent1));
   dependentList.insert(myDepList.getEntryRCP(dependent2));
 
   RCP<BoolVisualDependency> falseBoolVisDep = rcp(
     new BoolVisualDependency(
       myDepList.getEntryRCP(dependee2),
       dependentList,
       false));
 
   myDepSheet->addDependency(trueBoolVisDep);
   myDepSheet->addDependency(falseBoolVisDep);
 
   RCP<DependencySheet> readInDepSheet = rcp(new DependencySheet);
 
   XMLParameterListWriter plWriter;
   XMLObject xmlOut = plWriter.toXML(myDepList, myDepSheet);
   out << xmlOut.toString();
 
   RCP<ParameterList> readInList =
     writeThenReadPL(myDepList, myDepSheet, readInDepSheet);
 
   RCP<ParameterEntry> readinDependee1 = readInList->getEntryRCP(dependee1);
   RCP<ParameterEntry> readinDependent1 = readInList->getEntryRCP(dependent1);
   RCP<ParameterEntry> readinDependee2 = readInList->getEntryRCP(dependee2);
   RCP<ParameterEntry> readinDependent2 = readInList->getEntryRCP(dependent2);
 
   RCP<Dependency> readinDep1 =
     *(readInDepSheet->getDependenciesForParameter(readinDependee1)->begin());
 
   RCP<Dependency> readinDep2 =
     *(readInDepSheet->getDependenciesForParameter(readinDependee2)->begin());
 
   BASIC_DEPENDENCY_TEST(readinDep1, BoolVisualDependency, 1, 1);
   VERIFY_DEPENDEE(readinDep1, readinDependee1);
   VERIFY_DEPENDENT(readinDep1, readinDependent1);
 
   BASIC_DEPENDENCY_TEST(readinDep2, BoolVisualDependency, 1, 2);
   VERIFY_DEPENDEE(readinDep2, readinDependee2);
   VERIFY_DEPENDENT(readinDep2, readinDependent1);
   VERIFY_DEPENDENT(readinDep2, readinDependent2);
 
 
   RCP<BoolVisualDependency> castedDep1 =
     rcp_dynamic_cast<BoolVisualDependency>(readinDep1, true);
   RCP<BoolVisualDependency> castedDep2 =
     rcp_dynamic_cast<BoolVisualDependency>(readinDep2, true);
 
   TEST_EQUALITY(castedDep1->getShowIf(), trueBoolVisDep->getShowIf());
   TEST_EQUALITY(castedDep2->getShowIf(), falseBoolVisDep->getShowIf());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [123/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		post_iterate_backward_no_filtering
	)

Definition at line 261 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::const_iterator citr_t;
   Array<int> a = tuple<int>(1, 2, 3);
   FilteredIterator<citr_t,SelectAll<int> > itr(a.end(), a.begin(), a.end());
   FilteredIterator<citr_t,SelectAll<int> > itr_begin(a.begin(), a.begin(), a.end());
   ECHO(--itr);
   ECHO(const int v0 = *itr--);
   TEST_EQUALITY_CONST(v0, 3);
   ECHO(const int v1 = *itr--);
   TEST_EQUALITY_CONST(v1, 2);
   ECHO(const int v2 = *itr);
   TEST_EQUALITY_CONST(v2, 1);
   TEST_ITER_EQUALITY(itr, itr_begin);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [124/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		set_doc_validator
	)

Definition at line 261 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
   ECHO(pl.set("my int", 3, "Some documentation", rcp(new DummyValidator)));
   ECHO(const ParameterEntry& my_int_param = getConst(pl).getEntry("my int"));
   TEST_EQUALITY_CONST(my_int_param.docString(), "Some documentation");
   TEST_NOTHROW(rcp_dynamic_cast<const DummyValidator>(my_int_param.validator(), true));
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [125/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		removeObj_idx_first
	)

Definition at line 268 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   typedef SIOVOCB::OrdinalIndex OI;
   typedef StringIndexedOrderedValueObjectContainer<OI>::ConstIterator ConstIterator;
   ECHO(StringIndexedOrderedValueObjectContainer<OI> oc);
   ECHO(oc.setObj("c", 1));
   ECHO(oc.setObj("a", 2));
   ECHO(oc.setObj("b", 3));
   TEST_EQUALITY_CONST(oc.numObjects(), 3);
   TEST_EQUALITY_CONST(oc.numStorage(), 3);
   ECHO(const OI &b = *oc.getObjPtr("b"));
   ECHO(oc.removeObj(0));
   TEST_EQUALITY_CONST(oc.numObjects(), 2);
   TEST_EQUALITY_CONST(oc.numStorage(), 3);
   TEST_EQUALITY(&b, oc.getObjPtr("b").get());
   ECHO(ConstIterator itr = oc.begin());
   TEST_EQUALITY_CONST(itr->first, "a");
   TEST_EQUALITY_CONST(itr->second.idx, 2);
   TEST_EQUALITY_CONST(itr->isActive(), true);
   ECHO(++itr);
   TEST_EQUALITY_CONST(itr->first, "b");
   TEST_EQUALITY_CONST(itr->second.idx, 3);
   TEST_EQUALITY_CONST(itr->isActive(), true);
   ECHO(++itr);
   TEST_ITER_EQUALITY(itr, oc.end());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [126/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		set_invalid_int_first
	)

Definition at line 271 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
   ECHO(const RCP<ParameterEntryValidator>
     validator(new Teuchos::EnhancedNumberValidator<int>(0, 1)));
   TEST_THROW(pl.set("my int", -1, "", validator),
     Exceptions::InvalidParameterValue);
   TEST_EQUALITY_CONST(pl.numParams(), 0);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [127/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ObjectBuilder	,
		getObjectName
	)

Definition at line 275 of file ObjectBuilder_UnitTests.cpp.

                                                          {
   const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>("Foo", "Foo Type");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooB>(),"Foo B");
   const RCP<ParameterList> pl = parameterList();
   pl->setParameters(*ob->getValidParameters()); // copy parameters
   pl->set("Foo Type", "Foo A"); // change default
   // 1.
   TEST_EQUALITY_CONST( ob->getObjectName(), "Foo B" );
   // 2.
   ob->setParameterList(pl);
   TEST_EQUALITY_CONST( ob->getObjectName(), "Foo A" );
 }

◆ TEUCHOS_UNIT_TEST() [128/224]

Teuchos::TEUCHOS_UNIT_TEST	(	RCPNodeHandle	,
		add_New_RCPNode_add_two_nodes_same_obj
	)

Definition at line 277 of file RCPNodeHandle_UnitTests.cpp.

 {
   SET_RCPNODE_TRACING();
   ECHO(C *c_ptr = new C);
   ECHO(RCPNode *node_c = basicRCPNodeNoAlloc<C>(c_ptr, true));
   ECHO(RCPNode *node_b1 = basicRCPNodeNoAlloc<B1>(c_ptr, true));
   ECHO(const int numActiveNodesBase = RCPNodeTracer::numActiveRCPNodes());
   ECHO(RCPNodeTracer::addNewRCPNode(node_c, "dummy"));
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase+1);
 #ifdef HAS_TEUCHOS_GET_BASE_OBJ_VOID_PTR
   // We can detect that these are the same object!
   TEST_THROW(RCPNodeTracer::addNewRCPNode(node_b1, "dummy"), DuplicateOwningRCPError);
 #else
   // We can not detect if these are the same object!
   ECHO(RCPNodeTracer::addNewRCPNode(node_b1, "dummy"));
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase+2);
   ECHO(RCPNodeTracer::removeRCPNode(node_b1));
 #endif
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase+1);
   ECHO(RCPNodeTracer::removeRCPNode(node_c));
   TEST_EQUALITY(RCPNodeTracer::numActiveRCPNodes(), numActiveNodesBase);
   ECHO(node_b1->has_ownership(false));
   ECHO(deleteRCPNode(&node_b1));
   ECHO(deleteRCPNode(&node_c));
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [129/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		pre_iterate_forward_filter_even
	)

Definition at line 278 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::const_iterator citr_t;
   Array<int> a = tuple<int>(1, 2, 3, 4);
   FilteredIterator<citr_t,SelectEven<int> > itr(a.begin(), a.begin(), a.end());
   FilteredIterator<citr_t,SelectEven<int> > itr_end(a.end(), a.begin(), a.end());
   TEST_ITER_INEQUALITY(itr, itr_end);
   TEST_EQUALITY_CONST(*itr, 2);
   ECHO(++itr);
   TEST_EQUALITY_CONST(*itr, 4);
   ECHO(++itr);
   TEST_ITER_EQUALITY(itr, itr_end);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [130/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		set_invalid_int_second
	)

Definition at line 282 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
   ECHO(const RCP<ParameterEntryValidator>
     validator(new Teuchos::EnhancedNumberValidator<int>(0, 1)));
   TEST_NOTHROW(pl.set("my int", 1, "", validator));
   TEST_EQUALITY_CONST(pl.numParams(), 1);
   TEST_EQUALITY_CONST(pl.get<int>("my int"), 1);
   TEST_THROW(pl.set("my int", -1), Exceptions::InvalidParameterValue);
   TEST_EQUALITY_CONST(pl.get<int>("my int"), 1);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [131/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Validators	,
		anyNumberValidator
	)

Definition at line 286 of file Validator_UnitTest.cpp.

 {
     RCP<ParameterList> userList = rcp(new ParameterList("User List"));
     RCP<ParameterList> validList = rcp(new ParameterList("Valid List"));
 
   Teuchos::AnyNumberParameterEntryValidator::AcceptedTypes intDoubleTypes;
   intDoubleTypes.allowString(false);
   Teuchos::AnyNumberParameterEntryValidator::AcceptedTypes intStringTypes;
   intStringTypes.allowDouble(false);
   Teuchos::AnyNumberParameterEntryValidator::AcceptedTypes intTypes;
   intTypes.allowDouble(false);
   intTypes.allowString(false);
 
   // set up validators to test
   // default prefers double and allows string and int
   RCP<Teuchos::AnyNumberParameterEntryValidator> allValidator =
     Teuchos::rcp( new Teuchos::AnyNumberParameterEntryValidator() );
   RCP<Teuchos::AnyNumberParameterEntryValidator> intDoubleValidator =
     Teuchos::rcp( new Teuchos::AnyNumberParameterEntryValidator(
     Teuchos::AnyNumberParameterEntryValidator::PREFER_DOUBLE, intDoubleTypes) );
   RCP<Teuchos::AnyNumberParameterEntryValidator> intStringValidator =
     Teuchos::rcp( new Teuchos::AnyNumberParameterEntryValidator(
     Teuchos::AnyNumberParameterEntryValidator::PREFER_INT, intStringTypes) );
   RCP<Teuchos::AnyNumberParameterEntryValidator> intValidator =
     Teuchos::rcp( new Teuchos::AnyNumberParameterEntryValidator(
     Teuchos::AnyNumberParameterEntryValidator::PREFER_INT, intTypes) );
 
   // first check the 'good' setups which do not throw
   TEST_NOTHROW(validList->set( "allParameter", "1.1", "documentation",
     allValidator));
   TEST_NOTHROW(validList->set( "allParameter", 1.1, "documentation",
     allValidator));
   TEST_NOTHROW(validList->set( "allParameter", "1", "documentation",
     allValidator));
   TEST_NOTHROW(validList->set( "allParameter", 1, "documentation",
     allValidator));
   TEST_NOTHROW(validList->set( "intDoubleParameter", 1.1, "documentation",
     intDoubleValidator));
   TEST_NOTHROW(validList->set( "intDoubleParameter", 1, "documentation",
     intDoubleValidator));
   TEST_NOTHROW(validList->set( "intStringParameter", "1", "documentation",
     intStringValidator));
   TEST_NOTHROW(validList->set( "intStringParameter", 1, "documentation",
     intStringValidator));
   TEST_NOTHROW(validList->set( "intParameter", 1, "documentation",
     intValidator));
 
   // This was a special case that might warrant discussion.
   // The issue is for validators which accept string/int but not double.
   // In the original setup the validator would always call getDouble
   // internally and accept a string of "1.1" without error.
   TEST_NOTHROW(validList->set( "intStringParameter", "1.1", "documentation",
     intStringValidator));
 
   //
   // these are some cases which  throw independent of HAVE_TEUCHOSCORE_CXX11
   //
 
   // if string it not allowed you can't use a string ever
   TEST_THROW(validList->set( "intDoubleParameter", "1.1", "documentation",
     intDoubleValidator), Exceptions::InvalidParameterType);
 
    // it also throws for a double number - double not allowed
   TEST_THROW(validList->set( "intStringParameter", 1.1, "documentation",
     intStringValidator), Exceptions::InvalidArgument);
 
   // for int only it can't be a string - any string will throw
   TEST_THROW(validList->set( "intParameter", "1", "documentation",
     intValidator), Exceptions::InvalidParameter);
 
   // this int only it can't be a double because double is not allowed
   TEST_THROW(validList->set( "intParameter", 1.1, "documentation",
     intValidator), Exceptions::InvalidParameter);
 
   //
   // these behaviors now depend on HAVE_TEUCHOSCORE_CXX11
   // std::stod and std::stoi will be used for HAVE_TEUCHOSCORE_CXX11
   // std::atof and std::atoi will be used for no CXX11
   //
 #ifdef HAVE_TEUCHOSCORE_CXX11
   // for double types we throw for badly formatted string on std::stod
   // this will check the double type first because it is PREFER_DOUBLE
   TEST_THROW(validList->set( "allParameter", "1.1x", "documentation",
     allValidator), Exceptions::InvalidArgument);
   TEST_THROW(validList->set( "intDoubleParameter", "1.1x", "documentation",
     allValidator), Exceptions::InvalidArgument);
   TEST_THROW(validList->set( "allParameter", "x1.1", "documentation",
     allValidator), Exceptions::InvalidArgument);
   TEST_THROW(validList->set( "intDoubleParameter", "x1.1", "documentation",
     allValidator), Exceptions::InvalidArgument);
   // for int/string but no double - std::stoi throws for invalid formatting
   TEST_THROW(validList->set( "intStringParameter", "1x", "documentation",
     intStringValidator), Exceptions::InvalidArgument);
   TEST_THROW(validList->set( "intStringParameter", "x1", "documentation",
     intStringValidator), Exceptions::InvalidArgument);
   TEST_THROW(validList->set( "intStringParameter", "1 x", "documentation",
     intStringValidator), Exceptions::InvalidArgument);
 #else
   // for int/double/string std::atod does NOT throw - this is the old behavior
   // this is different now when HAVE_TEUCHOSCORE_CXX11 is ON - see above
   TEST_NOTHROW(validList->set( "allParameter", "1.1x", "documentation",
     allValidator));
   // for int/string std::atoi does NOT throw - this is the old behavior
   // this is different now when HAVE_TEUCHOSCORE_CXX11 is ON - see above
   TEST_NOTHROW(validList->set( "intStringParameter", "1.1x", "documentation",
     intStringValidator));
 #endif
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [132/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		pre_iterate_forward_filter_odd
	)

Definition at line 293 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::const_iterator citr_t;
   Array<int> a = tuple<int>(1, 2, 3, 4);
   FilteredIterator<citr_t,SelectOdd<int> > itr(a.begin(), a.begin(), a.end());
   FilteredIterator<citr_t,SelectOdd<int> > itr_end(a.end(), a.begin(), a.end());
   TEST_ITER_INEQUALITY(itr, itr_end);
   TEST_EQUALITY_CONST(*itr, 1);
   ECHO(++itr);
   TEST_EQUALITY_CONST(*itr, 3);
   ECHO(++itr);
   TEST_ITER_EQUALITY(itr, itr_end);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [133/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		set_get_entry
	)

Definition at line 295 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
   ECHO(pl.setEntry("my int", ParameterEntry(as<int>(3), true, true, "Some doc", rcp(new DummyValidator))));
   ECHO(const ParameterEntry& my_int_param = getConst(pl).getEntry("my int"));
   TEST_EQUALITY_CONST(my_int_param.docString(), "Some doc");
   ECHO(const int my_int_1 = my_int_param.getValue<int>(0));
   TEST_EQUALITY_CONST(my_int_1, 3);
   TEST_EQUALITY_CONST(my_int_param.isUsed(), true);
   TEST_EQUALITY_CONST(my_int_param.isList(), false); // The isList entry is ignored!
   TEST_INEQUALITY_CONST(rcp_dynamic_cast<const DummyValidator>(my_int_param.validator(), true), null);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [134/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		removeObj_key_first
	)

Definition at line 297 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   typedef SIOVOCB::OrdinalIndex OI;
   typedef StringIndexedOrderedValueObjectContainer<OI>::ConstIterator ConstIterator;
   ECHO(StringIndexedOrderedValueObjectContainer<OI> oc);
   ECHO(oc.setObj("c", 1));
   ECHO(oc.setObj("a", 2));
   ECHO(oc.setObj("b", 3));
   TEST_EQUALITY_CONST(oc.numObjects(), 3);
   TEST_EQUALITY_CONST(oc.numStorage(), 3);
   ECHO(const OI &b = *oc.getObjPtr("b"));
   ECHO(oc.removeObj("c"));
   TEST_EQUALITY_CONST(oc.numObjects(), 2);
   TEST_EQUALITY_CONST(oc.numStorage(), 3);
   TEST_EQUALITY(&b, oc.getObjPtr("b").get());
   ECHO(ConstIterator itr = oc.begin());
   TEST_EQUALITY_CONST(itr->first, "a");
   TEST_EQUALITY_CONST(itr->second.idx, 2);
   TEST_EQUALITY_CONST(itr->isActive(), true);
   ECHO(++itr);
   TEST_EQUALITY_CONST(itr->first, "b");
   TEST_EQUALITY_CONST(itr->second.idx, 3);
   TEST_EQUALITY_CONST(itr->isActive(), true);
   ECHO(++itr);
   TEST_ITER_EQUALITY(itr, oc.end());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [135/224]

Teuchos::TEUCHOS_UNIT_TEST	(	TimeMonitor	,
		YamlLabelQuoting
	)

Definition at line 303 of file TimeMonitor_UnitTests.cpp.

   {
     using Teuchos::Array;
     using Teuchos::ParameterList;
     using Teuchos::parameterList;
     using Teuchos::RCP;
     using Teuchos::Time;
     typedef Array<std::string>::size_type size_type;
 
     Array<std::string> inputLabels, outputLabels;
 
     // Make sure to exercise things that don't need quoting, like
     // spaces and certain punctuation, as well as things that do need
     // quoting, like colons, inner double quotes, and backslashes.
     inputLabels.push_back ("NoQuotingNeeded");
     inputLabels.push_back ("No quoting needed");
     inputLabels.push_back ("\"AlreadyQuotedNoQuotingNeeded\"");
     inputLabels.push_back ("\"Already quoted, no quoting needed\"");
     inputLabels.push_back ("\"Already quoted: quoting needed\"");
     inputLabels.push_back ("NotQuoted:QuotingNeeded");
     inputLabels.push_back ("Not quoted: quoting needed");
     // Test both individual double quotes, and pairs of double quotes.
     inputLabels.push_back ("Not quoted \" quoting needed");
     inputLabels.push_back ("Not quoted \" \" quoting needed");
     inputLabels.push_back ("\"Already quoted \" quoting needed\"");
     inputLabels.push_back ("\"Already quoted \" \" quoting needed\"");
     // Remember that in C strings, a double backslash turns into a
     // single backslash.  Our YAML output routine should turn each
     // single backslash back into a double backslash.
     inputLabels.push_back ("Not quoted \\ quoting needed");
     inputLabels.push_back ("Not quoted \\\\ quoting needed");
     inputLabels.push_back ("Not quoted \\ \\ quoting needed");
     inputLabels.push_back ("\"Already quoted \\ quoting needed\"");
     inputLabels.push_back ("\"Already quoted \\\\ quoting needed\"");
     inputLabels.push_back ("\"Already quoted \\ \\ quoting needed\"");
 
     outputLabels.push_back ("NoQuotingNeeded");
     outputLabels.push_back ("No quoting needed");
     outputLabels.push_back ("\"AlreadyQuotedNoQuotingNeeded\"");
     outputLabels.push_back ("\"Already quoted, no quoting needed\"");
     outputLabels.push_back ("\"Already quoted: quoting needed\"");
     outputLabels.push_back ("\"NotQuoted:QuotingNeeded\"");
     outputLabels.push_back ("\"Not quoted: quoting needed\"");
     outputLabels.push_back ("\"Not quoted \\\" quoting needed\"");
     outputLabels.push_back ("\"Not quoted \\\" \\\" quoting needed\"");
     outputLabels.push_back ("\"Already quoted \\\" quoting needed\"");
     outputLabels.push_back ("\"Already quoted \\\" \\\" quoting needed\"");
     outputLabels.push_back ("\"Not quoted \\\\ quoting needed\"");
     outputLabels.push_back ("\"Not quoted \\\\\\\\ quoting needed\"");
     outputLabels.push_back ("\"Not quoted \\\\ \\\\ quoting needed\"");
     outputLabels.push_back ("\"Already quoted \\\\ quoting needed\"");
     outputLabels.push_back ("\"Already quoted \\\\\\\\ quoting needed\"");
     outputLabels.push_back ("\"Already quoted \\\\ \\\\ quoting needed\"");
 
     // Sanity check.
     TEUCHOS_TEST_FOR_EXCEPTION(
       inputLabels.size () != outputLabels.size (),
       std::logic_error,
       "The number of input labels is different than the number of output labels."
       "  Please ask a Teuchos developer to make sure that every test input "
       "label has a corresponding output label.");
 
     Array<RCP<Time> > timers;
     for (size_type i = 0; i < inputLabels.size (); ++i) {
       timers.push_back (TimeMonitor::getNewCounter (inputLabels[i]));
     }
 
     // The actual number of operations in the loop is proportional to
     // the cube of the loop length.  Adjust the quantities below as
     // necessary to ensure the timer reports a nonzero elapsed time
     // for each of the invocations.
     const size_t loopLength = 25;
     for (int k = 0; k < 3; ++k) {
       for (size_type i = 0; i < timers.size (); ++i) {
         TimeMonitor timeMon (* timers[i]);
         slowLoop (loopLength);
       }
     }
 
     { // YAML output, compact style.
       std::ostringstream oss;
       RCP<ParameterList> reportParams =
         parameterList (* (TimeMonitor::getValidReportParameters ()));
       reportParams->set ("Report format", "YAML");
       reportParams->set ("YAML style", "compact");
       TimeMonitor::report (oss, reportParams);
 
       // Echo output to the FancyOStream out (which is a standard unit
       // test argument).  Output should only appear in "show all test
       // details" mode.
       out << oss.str () << std::endl;
 
       // Make sure that all timer labels appear correctly in the output.
       for (size_type i = 0; i < inputLabels.size(); ++i) {
         const size_t pos = oss.str ().find (outputLabels[i]);
         TEST_INEQUALITY(pos, std::string::npos);
       }
     }
 
     { // YAML output, spacious style.
       std::ostringstream oss;
       RCP<ParameterList> reportParams =
         parameterList (* (TimeMonitor::getValidReportParameters ()));
       reportParams->set ("Report format", "YAML");
       reportParams->set ("YAML style", "spacious");
       TimeMonitor::report (oss, reportParams);
 
       // Echo output to the FancyOStream out (which is a standard unit
       // test argument).  Output should only appear in "show all test
       // details" mode.
       out << oss.str () << std::endl;
 
       // Make sure that all timer labels appear correctly in the output.
       for (size_type i = 0; i < inputLabels.size(); ++i) {
         const size_t pos = oss.str ().find (outputLabels[i]);
         TEST_INEQUALITY(pos, std::string::npos);
       }
     }
 
     // This sets up for the next unit test.
     TimeMonitor::clearCounters ();
   }

◆ TEUCHOS_UNIT_TEST() [136/224]

Teuchos::TEUCHOS_UNIT_TEST	(	RCPNodeHandle	,
		remove_RCPNode_missing_node
	)

Definition at line 305 of file RCPNodeHandle_UnitTests.cpp.

 {
   SET_RCPNODE_TRACING();
   RCPNode *node = basicRCPNode<A>(true);
   TEST_THROW(RCPNodeTracer::removeRCPNode(node), std::logic_error);
   deleteRCPNode(&node);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [137/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ObjectBuilder	,
		create
	)

Definition at line 306 of file ObjectBuilder_UnitTests.cpp.

                                                   {
   const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>("Foo", "Foo Type");
   TEST_EQUALITY_CONST( ob->create("None"), null ); // 7.
   TEST_EQUALITY_CONST( ob->create(), null ); // 1.
   ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooB>(),"Foo B");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooC>(),"Foo C");
   out << "op.getValidParamters():\n";
   printValidParameters(*ob, out);
   const RCP<ParameterList> pl = parameterList();
   pl->setParameters(*ob->getValidParameters());
   pl->set("Foo Type","None");
   ob->setParameterList(pl);
   TEST_EQUALITY_CONST( ob->create(), null ); // 2.
   pl->set("Foo Type", "Foo B");
   pl->sublist("Foo B").set("String","BB");
   pl->sublist("Foo C").set("String","CC");
   {
     const RCP<Foo> foo = ob->create();
     const RCP<FooB> fooB = rcp_dynamic_cast<FooB>(foo,false);
     TEST_EQUALITY_CONST( is_null(fooB), false ); // 3.
     TEST_EQUALITY_CONST( foo->getString(), "BB" ); // 5a.
   }
   ob->unsetParameterList();
   {
     const RCP<Foo> foo = ob->create();
     const RCP<FooC> fooC = rcp_dynamic_cast<FooC>(foo,false);
     TEST_EQUALITY_CONST( is_null(fooC), false ); // 3a.
     TEST_EQUALITY_CONST( foo->getString(), "C" ); // 5.
   }
   {
     const RCP<Foo> foo = ob->create("Foo A");
     const RCP<FooA> fooA = rcp_dynamic_cast<FooA>(foo,false);
     TEST_EQUALITY_CONST( is_null(fooA), false ); // 4.
   }
   ob->setParameterList(pl);
   {
     const RCP<Foo> foo = ob->create("Foo A");
     const RCP<FooA> fooA = rcp_dynamic_cast<FooA>(foo,false);
     TEST_EQUALITY_CONST( is_null(fooA), false ); // 4.
   }
   {
     RCP<Foo> foo;
     TEST_THROW( foo = ob->create("Foo D"), std::logic_error ); // 4a.
   }
   // 6. ???
 }

◆ TEUCHOS_UNIT_TEST() [138/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		post_iterate_forward_filter_even
	)

Definition at line 308 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::const_iterator citr_t;
   Array<int> a = tuple<int>(1, 2, 3, 4);
   FilteredIterator<citr_t,SelectEven<int> > itr(a.begin(), a.begin(), a.end());
   FilteredIterator<citr_t,SelectEven<int> > itr_end(a.end(), a.begin(), a.end());
   TEST_ITER_INEQUALITY(itr, itr_end);
   ECHO(const int v0 = *itr++);
   TEST_EQUALITY_CONST(v0, 2);
   ECHO(const int v1 = *itr++);
   TEST_EQUALITY_CONST(v1, 4);
   TEST_ITER_EQUALITY(itr, itr_end);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [139/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		set_int_twice_keep_validator
	)

Definition at line 309 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
   ECHO(pl.setEntry("my int", ParameterEntry(as<int>(3), true, true, "Some doc", rcp(new DummyValidator))));
   {
     ECHO(const ParameterEntry& my_int_param = getConst(pl).getEntry("my int"));
     TEST_INEQUALITY_CONST(rcp_dynamic_cast<const DummyValidator>(my_int_param.validator(), true), null);
   }
   TEST_EQUALITY_CONST(pl.get<int>("my int"), 3);
   ECHO(pl.set("my int", 4));
   TEST_EQUALITY_CONST(pl.get<int>("my int"), 4);
   {
     ECHO(const ParameterEntry& my_int_param = getConst(pl).getEntry("my int"));
     TEST_INEQUALITY_CONST(rcp_dynamic_cast<const DummyValidator>(my_int_param.validator(), true), null);
   }
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [140/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		post_iterate_forward_filter_odd
	)

Definition at line 323 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::const_iterator citr_t;
   Array<int> a = tuple<int>(1, 2, 3, 4);
   FilteredIterator<citr_t,SelectOdd<int> > itr(a.begin(), a.begin(), a.end());
   FilteredIterator<citr_t,SelectOdd<int> > itr_end(a.end(), a.begin(), a.end());
   TEST_ITER_INEQUALITY(itr, itr_end);
   ECHO(const int v0 = *itr++);
   TEST_EQUALITY_CONST(v0, 1);
   ECHO(const int v1 = *itr++);
   TEST_EQUALITY_CONST(v1, 3);
   TEST_ITER_EQUALITY(itr, itr_end);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [141/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		removeObj_idx_middle
	)

Definition at line 326 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   typedef SIOVOCB::OrdinalIndex OI;
   typedef StringIndexedOrderedValueObjectContainer<OI>::ConstIterator ConstIterator;
   ECHO(StringIndexedOrderedValueObjectContainer<OI> oc);
   ECHO(oc.setObj("c", 1));
   ECHO(oc.setObj("a", 2));
   ECHO(oc.setObj("b", 3));
   TEST_EQUALITY_CONST(oc.numObjects(), 3);
   TEST_EQUALITY_CONST(oc.numStorage(), 3);
   ECHO(const OI &c = *oc.getObjPtr("c"));
   ECHO(oc.removeObj(1));
   TEST_EQUALITY(&c, oc.getObjPtr("c").get());
   ECHO(ConstIterator itr = oc.begin());
   TEST_EQUALITY_CONST(oc.numObjects(), 2);
   TEST_EQUALITY_CONST(oc.numStorage(), 3);
   TEST_EQUALITY_CONST(itr->first, "c");
   TEST_EQUALITY_CONST(itr->second.idx, 1);
   TEST_EQUALITY_CONST(itr->isActive(), true);
   ECHO(++itr);
   TEST_EQUALITY_CONST(itr->first, "b");
   TEST_EQUALITY_CONST(itr->second.idx, 3);
   TEST_EQUALITY_CONST(itr->isActive(), true);
   ECHO(++itr);
   TEST_ITER_EQUALITY(itr, oc.end());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [142/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		set_get_char_str
	)

Definition at line 327 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
 
   ECHO(char dummy_str_1[] = "dummy str 1");
   ECHO(pl.set("dummy 1", dummy_str_1));
   ECHO(const std::string dummy_1 = pl.get<std::string>("dummy 1"));
   TEST_EQUALITY_CONST(dummy_1, "dummy str 1");
 
   ECHO(const char dummy_str_const_2[] = "dummy str 2");
   ECHO(pl.set("dummy 2", dummy_str_const_2));
   ECHO(const std::string dummy_2 = pl.get<std::string>("dummy 2"));
   TEST_EQUALITY_CONST(dummy_2, "dummy str 2");
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [143/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		pre_iterate_backward_filter_even
	)

Definition at line 338 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::const_iterator citr_t;
   Array<int> a = tuple<int>(1, 2, 3, 4);
   FilteredIterator<citr_t,SelectEven<int> > itr(a.end(), a.begin(), a.end());
   FilteredIterator<citr_t,SelectEven<int> > itr_begin(a.begin(), a.begin(), a.end());
   ECHO(--itr);
   TEST_EQUALITY_CONST(*itr, 4);
   ECHO(--itr);
   TEST_EQUALITY_CONST(*itr, 2);
   TEST_ITER_EQUALITY(itr, itr_begin);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [144/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		testVisualDeps
	)

Testing all the visual dependencies

Definition at line 340 of file Dependencies_UnitTests.cpp.

                                                        {
     RCP<ParameterList> My_deplist = RCP<ParameterList>(new ParameterList);
     RCP<DependencySheet> depSheet1 =
     RCP<DependencySheet>(new DependencySheet);
   /*
    * Two Simple NumberVisualDependency test
    */
 
     ParameterList
     simpleNumDepTestList = My_deplist->sublist(
         "NumberVisual Dependency List (double)",
         false,
         "Number visual Dependency testing list"
     );
         
     simpleNumDepTestList.set("Temperature",101.0);
     simpleNumDepTestList.set("Cheese to Fondue", "Swiss", "The cheese to fondue");
     simpleNumDepTestList.set("reverse param", "hello");
 
     RCP<NumberVisualDependency<double> > simpleNumDep =
     RCP<NumberVisualDependency<double> >(
         new NumberVisualDependency<double>(
             simpleNumDepTestList.getEntryRCP("Temperature"),
             simpleNumDepTestList.getEntryRCP("Cheese to Fondue"),
       true
         )
     );
     RCP<NumberVisualDependency<double> > reverseNumDep =
     RCP<NumberVisualDependency<double> >(
         new NumberVisualDependency<double>(
             simpleNumDepTestList.getEntryRCP("Temperature"),
             simpleNumDepTestList.getEntryRCP("reverse param"),
       false
         )
     );
   depSheet1->addDependency(simpleNumDep);
   depSheet1->addDependency(reverseNumDep);
     simpleNumDep->evaluate();
     reverseNumDep->evaluate();
     TEST_ASSERT(simpleNumDep->isDependentVisible());
     TEST_ASSERT(!reverseNumDep->isDependentVisible());
     simpleNumDepTestList.set("Temperature",-1.0);
     simpleNumDep->evaluate();
     reverseNumDep->evaluate();
     TEST_ASSERT(!simpleNumDep->isDependentVisible());
     TEST_ASSERT(reverseNumDep->isDependentVisible());
 
 
     /*
      * complex Testing the NumberVisualDependency
      */
     ParameterList
     doubleVisualDepList = My_deplist->sublist(
         "NumberVisual Dependency List (double)",
         false,
         "Number visual Dependency testing list"
     );
         
     doubleVisualDepList.set(
     "Temperature",101.0, "The temperature of the fondue");
     doubleVisualDepList.set(
     "Cheese to Fondue", "Swiss", "The cheese to fondue");
   doubleVisualDepList.set("reverse param", "hello");
   RCP<SubtractionFunction<double> > fondueFunc = rcp(new
     SubtractionFunction<double>(100));
 
     RCP<NumberVisualDependency<double> > fondueDep =
     RCP<NumberVisualDependency<double> >(
         new NumberVisualDependency<double>(
             doubleVisualDepList.getEntryRCP("Temperature"),
             doubleVisualDepList.getEntryRCP("Cheese to Fondue"),
       true,
             fondueFunc
         )
     );
     RCP<NumberVisualDependency<double> > reverseFondueDep =
     RCP<NumberVisualDependency<double> >(
         new NumberVisualDependency<double>(
             doubleVisualDepList.getEntryRCP("Temperature"),
             doubleVisualDepList.getEntryRCP("reverse param"),
       false,
             fondueFunc
         )
     );
     depSheet1->addDependency(fondueDep);
     depSheet1->addDependency(reverseFondueDep);
     fondueDep->evaluate();
   reverseFondueDep->evaluate();
     TEST_ASSERT(fondueDep->isDependentVisible());
     TEST_ASSERT(!reverseFondueDep->isDependentVisible());
     doubleVisualDepList.set("Temperature",99.0);
     fondueDep->evaluate();
   reverseFondueDep->evaluate();
     TEST_ASSERT(!fondueDep->isDependentVisible());
     TEST_ASSERT(reverseFondueDep->isDependentVisible());
 
     /*
      * Testing the BoolVisualDependency
      */
     ParameterList&
     boolVisDepList = My_deplist->sublist(
         "Bool Visual Dependency List",
         false,
         "Bool Visual Dependency testing list."
     );
     boolVisDepList.set(
     "ShowPrecs", true, "Whether or not to should the Preciondtioner list");
     ParameterList
     Prec_List0 = boolVisDepList.sublist(
     "Preconditioner",false,"Sublist that defines the preconditioner.");
     Prec_List0.set("Type", "ILU", "The tpye of preconditioner to use");
     RCP<EnhancedNumberValidator<double> > droptolValidator =
     rcp(new EnhancedNumberValidator<double>(0,10,1e-3));
     Prec_List0.set(
     "Drop Tolerance", 1e-3,
     "The tolerance below which entries from the "
     "factorization are left out of the factors.", droptolValidator);
     RCP<BoolVisualDependency>
     precDep1 = RCP<BoolVisualDependency>(
         new BoolVisualDependency(
             boolVisDepList.getEntryRCP("ShowPrecs"),
             boolVisDepList.getEntryRCP("Preconditioner"),
             true
         )
     );
     depSheet1->addDependency(precDep1);
     precDep1->evaluate();
     TEST_ASSERT(precDep1->isDependentVisible());
     boolVisDepList.set("ShowPrecs", false);
     precDep1->evaluate();
     TEST_ASSERT(!precDep1->isDependentVisible());
 
 
 
     /*
      * Testing the StringVisualDepenency
      */
     ParameterList&
     stringVisDepList = My_deplist->sublist(
         "String Visual Dependency List",
         false,
         "String Visual Dependency testing list."
     );
     RCP<StringToIntegralParameterEntryValidator<int> >
     favCheeseValidator = rcp(
         new StringToIntegralParameterEntryValidator<int>(
             tuple<std::string>( "Swiss", "American", "Cheder" ),
             "Favorite Cheese"
         )
     );
 
     stringVisDepList.set("Favorite Cheese",
     "American", "Your favorite type of cheese", favCheeseValidator);
     RCP<EnhancedNumberValidator<int> >
     swissValidator = rcp(new EnhancedNumberValidator<int>(0,10));
     stringVisDepList.set("Swiss rating", 0,
     "How you rate swiss on a scale of 1 to 10", swissValidator);
     RCP<StringVisualDependency>
     swissDep1 = RCP<StringVisualDependency>(
         new StringVisualDependency(
             stringVisDepList.getEntryRCP("Favorite Cheese"),
             stringVisDepList.getEntryRCP("Swiss rating"),
             "Swiss",
             true
         )
     );
     depSheet1->addDependency(swissDep1);
     swissDep1->evaluate();
     TEST_ASSERT(!swissDep1->isDependentVisible());
     stringVisDepList.set("Favorite Cheese", "Swiss");
     swissDep1->evaluate();
     TEST_ASSERT(swissDep1->isDependentVisible());
 
     /*
      * String Visual Tester with multiple values
      */
     ParameterList multiStringVisDepList = My_deplist->sublist(
         "Multi String Visual Dependency List",
         false
     );
     RCP<StringToIntegralParameterEntryValidator<int> >
     favCheeseValidator2 = rcp(
         new StringToIntegralParameterEntryValidator<int>(
             tuple<std::string>( "Provalone", "Swiss", "American", "Cheder" ),
             "Favorite Cheese"
         )
     );
 
     multiStringVisDepList.set(
     "Favorite Cheese", "American",
     "Your favorite type of cheese", favCheeseValidator2);
     multiStringVisDepList.set("Swiss rating", 0,
     "How you rate swiss on a scale of 1 to 10", swissValidator);
     RCP<StringVisualDependency>
     swissDep2 = RCP<StringVisualDependency>(
         new StringVisualDependency(
             multiStringVisDepList.getEntryRCP("Favorite Cheese"),
             multiStringVisDepList.getEntryRCP("Swiss rating"),
             tuple<std::string>("Swiss", "Cheder"),
             true
         )
     );
     depSheet1->addDependency(swissDep2);
     swissDep2->evaluate();
     TEST_ASSERT(!swissDep2->isDependentVisible());
     multiStringVisDepList.set("Favorite Cheese", "Cheder");
     swissDep2->evaluate();
     TEST_ASSERT(swissDep2->isDependentVisible());
 
     /*
      * Another test of the NumberVisualDependency.
      */
     ParameterList
     numberVisDepList = My_deplist->sublist(
         "Number Visual Dependency List",
         false,
         "Number Visual Dependency testing list."
     );
     numberVisDepList.set("Ice", 50, "Ice stuff");
     numberVisDepList.set("Room Temp", 10, "Room temperature");
   RCP<SubtractionFunction<int> > visFunc = rcp(new
     SubtractionFunction<int>(32));
     RCP<NumberVisualDependency<int> >
     iceDep = RCP<NumberVisualDependency<int> >(
         new NumberVisualDependency<int>(
             numberVisDepList.getEntryRCP("Room Temp"),
             numberVisDepList.getEntryRCP("Ice"),
       true,
             visFunc
         )
     );
     depSheet1->addDependency(iceDep);
     iceDep->evaluate();
     TEST_ASSERT(!iceDep->isDependentVisible());
     numberVisDepList.set("Room Temp", 33);
     iceDep->evaluate();
     TEST_ASSERT(iceDep->isDependentVisible());
 
     /*
      * Test condition visual dependency
      */
     RCP<ParameterList> conVisDepList = sublist(
     My_deplist,"Condition Visual Dependency List", false);
     conVisDepList->set("double param", 4.0, "double parameter");
     conVisDepList->set("bool param", true, "bool parameter");
     conVisDepList->set("string param", "blah", "a string parameter");
     RCP<NumberCondition<double> > numberCon =
     rcp( new NumberCondition<double>(
       conVisDepList->getEntryRCP("double param")));
     RCP<BoolCondition> boolCon =
     rcp(new BoolCondition(conVisDepList->getEntryRCP("bool param")));
     Condition::ConstConditionList conList =
     tuple<RCP<const Condition> >(numberCon, boolCon);
     RCP<AndCondition> andCon = rcp(new AndCondition(conList));
     RCP<ConditionVisualDependency> conVisDep =
     rcp(new ConditionVisualDependency(
       andCon, conVisDepList->getEntryRCP("string param"), true));
     depSheet1->addDependency(conVisDep);
     conVisDep->evaluate();
     TEST_ASSERT(conVisDep->isDependentVisible());
     conVisDepList->set("bool param", false);
     conVisDep->evaluate();
     TEST_ASSERT(!conVisDep->isDependentVisible());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [145/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		set_get_string
	)

Definition at line 344 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
 
   ECHO(const std::string dummy_str = "dummy str");
   ECHO(pl.set("my str", dummy_str));
   ECHO(const std::string my_str = pl.get<std::string>("my str"));
   TEST_EQUALITY_CONST(my_str, "dummy str");
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [146/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		pre_iterate_backward_filter_odd
	)

Definition at line 352 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::const_iterator citr_t;
   Array<int> a = tuple<int>(1, 2, 3, 4);
   FilteredIterator<citr_t,SelectOdd<int> > itr(a.end(), a.begin(), a.end());
   FilteredIterator<citr_t,SelectOdd<int> > itr_begin(a.begin(), a.begin(), a.end());
   ECHO(--itr);
   TEST_EQUALITY_CONST(*itr, 3);
   ECHO(--itr);
   TEST_EQUALITY_CONST(*itr, 1);
   TEST_ITER_EQUALITY(itr, itr_begin);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [147/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		removeObj_key_middle
	)

Definition at line 355 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   typedef SIOVOCB::OrdinalIndex OI;
   typedef StringIndexedOrderedValueObjectContainer<OI>::ConstIterator ConstIterator;
   ECHO(StringIndexedOrderedValueObjectContainer<OI> oc);
   ECHO(oc.setObj("c", 1));
   ECHO(oc.setObj("a", 2));
   ECHO(oc.setObj("b", 3));
   TEST_EQUALITY_CONST(oc.numObjects(), 3);
   TEST_EQUALITY_CONST(oc.numStorage(), 3);
   ECHO(const OI &c = *oc.getObjPtr("c"));
   ECHO(oc.removeObj("a"));
   TEST_EQUALITY(&c, oc.getObjPtr("c").get());
   TEST_EQUALITY_CONST(oc.numObjects(), 2);
   TEST_EQUALITY_CONST(oc.numStorage(), 3);
   ECHO(ConstIterator itr = oc.begin());
   TEST_EQUALITY_CONST(itr->first, "c");
   TEST_EQUALITY_CONST(itr->second.idx, 1);
   TEST_EQUALITY_CONST(itr->isActive(), true);
   ECHO(++itr);
   TEST_EQUALITY_CONST(itr->first, "b");
   TEST_EQUALITY_CONST(itr->second.idx, 3);
   TEST_EQUALITY_CONST(itr->isActive(), true);
   ECHO(++itr);
   TEST_ITER_EQUALITY(itr, oc.end());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [148/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		get_nonexisting_param
	)

Definition at line 356 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
   TEST_THROW(pl.getEntry("Does not exist 1"), Exceptions::InvalidParameterName);
   TEST_THROW(pl.get<int>("Does not exist 2"), Exceptions::InvalidParameterName);
   TEST_THROW(getConst(pl).get<int>("Does not exist 3"), Exceptions::InvalidParameterName);
   TEST_EQUALITY(pl.getPtr<int>("Does not exist 4"), static_cast<int*>(0));
   TEST_EQUALITY(getConst(pl).getPtr<int>("Does not exist 5"), static_cast<const int*>(0));
   ECHO(char raw_str[] = "dummy");
   TEST_EQUALITY_CONST(pl.get("Does not exist 6", raw_str), "dummy");
   ECHO(const char raw_c_str[] = "dummy");
   TEST_EQUALITY_CONST(pl.get("Does not exist 7", raw_c_str), "dummy");
   ECHO(const std::string str = "dummy");
   TEST_EQUALITY_CONST(pl.get("Does not exist 8", str), "dummy");
   TEST_THROW(pl.getEntry("Does not exist 9"), Exceptions::InvalidParameterName);
   TEST_THROW(getConst(pl).getEntry("Does not exist 10"), Exceptions::InvalidParameterName);
   TEST_EQUALITY(pl.getEntryPtr("Does not exist 11"), static_cast<ParameterEntry*>(0));
   TEST_EQUALITY(getConst(pl).getEntryPtr("Does not exist 12"), static_cast<const ParameterEntry*>(0));
   TEST_EQUALITY(pl.getEntryRCP("Does not exist 13"), RCP<ParameterEntry>());
   TEST_EQUALITY(getConst(pl).getEntryRCP("Does not exist 14"), RCP<const ParameterEntry>());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [149/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ObjectBuilder	,
		setParameterList
	)

Definition at line 365 of file ObjectBuilder_UnitTests.cpp.

                                                             {
     RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>();
     ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
     RCP<ParameterList> pl = null;
     TEST_NOTHROW( ob->setParameterList(pl) );
     pl = parameterList();
     TEST_NOTHROW( ob->setParameterList(pl) );
     pl->set("Hello","World");
     TEST_THROW( ob->setParameterList(pl), std::logic_error ); // 1.
 #ifdef TEUCHOS_DEBUG
     TEST_THROW( ob->unsetParameterList(), std::logic_error ); // 2.
     TEST_THROW( ob->create(), std::logic_error ); // 3.
     TEST_THROW( ob = null, std::logic_error ); // 4.
 #else // TEUCHOS_DEBUG
     TEST_NOTHROW( ob->unsetParameterList() );
     RCP<Foo> foo;
     TEST_NOTHROW( foo = ob->create() );
     const RCP<FooA> fooA = rcp_dynamic_cast<FooA>(foo,false);
     TEST_EQUALITY_CONST( is_null(fooA), false );
     TEST_NOTHROW( ob = null );
 #endif // TEUCHOS_DEBUG
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [150/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		post_iterate_backward_filter_even
	)

Definition at line 366 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::const_iterator citr_t;
   Array<int> a = tuple<int>(1, 2, 3, 4);
   FilteredIterator<citr_t,SelectEven<int> > itr(a.end(), a.begin(), a.end());
   FilteredIterator<citr_t,SelectEven<int> > itr_begin(a.begin(), a.begin(), a.end());
   ECHO(--itr);
   ECHO(const int v0 = *itr--);
   TEST_EQUALITY_CONST(v0, 4);
   ECHO(const int v1 = *itr);
   TEST_EQUALITY_CONST(v1, 2);
   TEST_ITER_EQUALITY(itr, itr_begin);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [151/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Conditions	,
		ConditionSerializationExceptions
	)

Definition at line 378 of file Condition_Serialization_UnitTests.cpp.

                                                                        {
   ConditionXMLConverterDB::printKnownConverters(out);
   RCP<DependencySheet> depSheet = rcp(new DependencySheet);
 
 
   TEST_THROW(RCP<ParameterList> missingParameterList =
     getParametersFromXmlFile(
       "MissingParameterEntryDefinition.xml", depSheet),
     MissingParameterEntryDefinitionException);
 
   RCP<ParameterEntry> notInListParam = rcp(new ParameterEntry(3.0));
   RCP<NumberCondition<double> > doubleCon =
     rcp(new NumberCondition<double>(notInListParam));
 
   NumberConditionConverter<double> doubleConConverter;
   XMLParameterListWriter::EntryIDsMap emptyMap;
   XMLObject toWriteTo;
   TEST_THROW(doubleConConverter.fromConditiontoXML(doubleCon, emptyMap),
     MissingParameterEntryDefinitionException);
 
   TEST_THROW(RCP<ParameterList> missingValuesList =
     getParametersFromXmlFile(
       "MissingValuesTag.xml", depSheet),
     MissingValuesTagException);
 
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [152/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		get_existing_incorrect_type
	)

Definition at line 379 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
   pl.set("my int", 4);
   TEST_THROW(pl.get<double>("my int"), Exceptions::InvalidParameterType);
   // ToDo: Assert the contents of the error message
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [153/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		post_iterate_backward_filter_odd
	)

Definition at line 381 of file FilteredIterator_UnitTests.cpp.

 {
   typedef Array<int>::const_iterator citr_t;
   Array<int> a = tuple<int>(1, 2, 3, 4);
   FilteredIterator<citr_t,SelectOdd<int> > itr(a.end(), a.begin(), a.end());
   FilteredIterator<citr_t,SelectOdd<int> > itr_begin(a.begin(), a.begin(), a.end());
   ECHO(--itr);
   ECHO(const int v0 = *itr--);
   TEST_EQUALITY_CONST(v0, 3);
   ECHO(const int v1 = *itr);
   TEST_EQUALITY_CONST(v1, 1);
   TEST_ITER_EQUALITY(itr, itr_begin);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [154/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		removeObj_idx_last
	)

Definition at line 384 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   typedef SIOVOCB::OrdinalIndex OI;
   typedef StringIndexedOrderedValueObjectContainer<OI>::ConstIterator ConstIterator;
   ECHO(StringIndexedOrderedValueObjectContainer<OI> oc);
   ECHO(oc.setObj("c", 1));
   ECHO(oc.setObj("a", 2));
   ECHO(oc.setObj("b", 3));
   TEST_EQUALITY_CONST(oc.numObjects(), 3);
   TEST_EQUALITY_CONST(oc.numStorage(), 3);
   ECHO(const OI &a = *oc.getObjPtr("a"));
   ECHO(oc.removeObj(2));
   TEST_EQUALITY_CONST(oc.numObjects(), 2);
   TEST_EQUALITY_CONST(oc.numStorage(), 3);
   TEST_EQUALITY(&a, oc.getObjPtr("a").get());
   ECHO(ConstIterator itr = oc.begin());
   TEST_EQUALITY_CONST(itr->first, "c");
   TEST_EQUALITY_CONST(itr->second.idx, 1);
   TEST_EQUALITY_CONST(itr->isActive(), true);
   ECHO(++itr);
   TEST_EQUALITY_CONST(itr->first, "a");
   TEST_EQUALITY_CONST(itr->second.idx, 2);
   TEST_EQUALITY_CONST(itr->isActive(), true);
   ECHO(++itr);
   TEST_ITER_EQUALITY(itr, oc.end());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [155/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		getPtr
	)

Definition at line 388 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
   pl.set("my int", 4);
   TEST_EQUALITY_CONST(pl.getPtr<int>("Does not Exist"), static_cast<int*>(0));
   TEST_INEQUALITY_CONST(pl.getPtr<int>("my int"), static_cast<int*>(0));
   TEST_EQUALITY_CONST(*pl.getPtr<int>("my int"), 4);
   TEST_EQUALITY_CONST(pl.getPtr<double>("my int"), static_cast<double*>(0));
   TEST_EQUALITY_CONST(getConst(pl).getPtr<int>("Does not Exist"), static_cast<const int*>(0));
   TEST_INEQUALITY_CONST(getConst(pl).getPtr<int>("my int"), static_cast<int*>(0));
   TEST_EQUALITY_CONST(*getConst(pl).getPtr<int>("my int"), 4);
   TEST_EQUALITY_CONST(getConst(pl).getPtr<double>("my int"), static_cast<const double*>(0));
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [156/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Validators	,
		boolValidator
	)

Definition at line 395 of file Validator_UnitTest.cpp.

 {
   RCP<ParameterList> userList = rcp(new ParameterList("User List"));
   RCP<ParameterList> validList = rcp(new ParameterList("Valid List"));
 
   // first without validator - accepts only true/false
   validList->set( "justBool", false, "documentation" );
   TEST_NOTHROW(userList->set( "justBool", false));
   TEST_NOTHROW(userList->validateParameters(*validList));
   TEST_NOTHROW(userList->set( "justBool", true));
   TEST_NOTHROW(userList->validateParameters(*validList));
   // this will not validate because we did not add a bool validator
   TEST_NOTHROW(userList->set( "justBool", "true"));
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidParameterType);
   // this will not validate because we did not add a bool validator
   TEST_NOTHROW(userList->set( "justBool", "false"));
   TEST_THROW(userList->validateParameters(*validList),
     Exceptions::InvalidParameterType);
 
   // now with BoolParameterEntryValidator validator
   // accepts true/false/"true"/"false"
   RCP<Teuchos::BoolParameterEntryValidator> boolValidator =
     Teuchos::rcp( new Teuchos::BoolParameterEntryValidator() );
   userList = rcp(new ParameterList("User List")); // make a new list
   validList = rcp(new ParameterList("Valid List")); // make a new list
   validList->set( "boolOrString", false, "documentation", boolValidator );
   TEST_NOTHROW(userList->set( "boolOrString", false));
   TEST_NOTHROW(userList->validateParameters(*validList));
   TEST_NOTHROW(userList->set( "boolOrString", true));
   TEST_NOTHROW(userList->validateParameters(*validList));
   // this will validate because we added a bool validator
   TEST_NOTHROW(userList->set( "boolOrString", "true"));
   TEST_NOTHROW(userList->validateParameters(*validList));
   // this will validate because we added a bool validator
   TEST_NOTHROW(userList->set( "boolOrString", "false"));
   TEST_NOTHROW(userList->validateParameters(*validList));
   // but only "false" and "true" work - anything else will not validate
   TEST_NOTHROW(userList->set( "boolOrString", "falsex")); // sets ok
   TEST_THROW(userList->validateParameters(*validList), // but throws
     Exceptions::InvalidParameterType);
 
   // now with BoolParameterEntryValidator validator
   // but consider what happens if we created it using "false" instead of false
   // this should still work identically to the previous case
   userList = rcp(new ParameterList("User List")); // make a new list
   validList = rcp(new ParameterList("Valid List")); // make a new list
   validList->set( "boolOrString", "false", "documentation", boolValidator );
   TEST_NOTHROW(userList->set( "boolOrString", false));
   TEST_NOTHROW(userList->validateParameters(*validList));
   TEST_NOTHROW(userList->set( "boolOrString", true ));
   TEST_NOTHROW(userList->validateParameters(*validList));
   // this will validate because we added a bool validator
   TEST_NOTHROW(userList->set( "boolOrString", "true"));
   TEST_NOTHROW(userList->validateParameters(*validList));
   // this will validate because we added a bool validator
   TEST_NOTHROW(userList->set( "boolOrString", "false"));
   TEST_NOTHROW(userList->validateParameters(*validList));
   // but only "false" and "true" work - anything else will not validate
   TEST_NOTHROW(userList->set( "boolOrString", "falsex")); // sets ok
   TEST_THROW(userList->validateParameters(*validList), // but throws
     Exceptions::InvalidParameterType);
 
   // do another test using validateParametersAndSetDefaults
   userList = rcp(new ParameterList("User List")); // make a new list
   validList = rcp(new ParameterList("Valid List")); // make a new list
   // Default values for parameters are bool
   validList->set("boolOne", true, "doc", boolValidator);
   validList->set("boolTwo", false, "doc", boolValidator);
   bool defOne = validList->getEntry("boolOne").getValue(&defOne);
   bool defTwo = validList->getEntry("boolTwo").getValue(&defTwo);
 
   // Create user parameter list
   userList->set("boolOne", false);   // User can provide bool value...
   userList->set("boolTwo", "true");  // or string "true"/"false"
   TEST_NOTHROW(userList->validateParametersAndSetDefaults(*validList));
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [157/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		iterate_forward_past_end_throw
	)

Definition at line 399 of file FilteredIterator_UnitTests.cpp.

 {
   // Need to use an unchecked iterator to make sure class thows
   int a_raw = 1;
   FilteredIterator<int*,SelectAll<int> > itr_end((&a_raw)+1, &a_raw, (&a_raw)+1);
   FilteredIterator<int*,SelectAll<int> > itr = itr_end;
   TEST_THROW(++itr, RangeError);
   TEST_ITER_EQUALITY(itr, itr_end);
   TEST_THROW(itr++, RangeError);
   TEST_ITER_EQUALITY(itr, itr_end);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [158/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ObjectBuilder	,
		getParameterList
	)

Definition at line 399 of file ObjectBuilder_UnitTests.cpp.

                                                             {
   const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>();
   ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
   const RCP<const ParameterList> pl = ob->getParameterList();
   TEST_EQUALITY_CONST( is_null(pl), true ); // 1.
   const RCP<ParameterList> nonconstPL = parameterList();
   nonconstPL->set("Object Type","None");
   TEST_NOTHROW( ob->setParameterList(nonconstPL) );
   {
     const RCP<const ParameterList> newPL = ob->getParameterList();
     TEST_EQUALITY_CONST( nonconstPL.get(), newPL.get() ); // 2.
   }
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [159/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		getEntryRCP
	)

Definition at line 403 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
   pl.set("my int", 4);
   TEST_EQUALITY_CONST(pl.getEntryRCP("Does not Exist"), null);
   TEST_INEQUALITY_CONST(pl.getEntryRCP("my int"), null);
   TEST_EQUALITY_CONST(pl.getEntryRCP("my int")->getValue<int>(0), 4);
   TEST_EQUALITY_CONST(getConst(pl).getEntryRCP("Does not Exist"), null);
   TEST_INEQUALITY_CONST(getConst(pl).getEntryRCP("my int"), null);
   TEST_EQUALITY_CONST(getConst(pl).getEntryRCP("my int")->getValue<int>(0), 4);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [160/224]

Teuchos::TEUCHOS_UNIT_TEST	(	FilteredIterator	,
		iterate_backward_past_begin_throw
	)

Definition at line 412 of file FilteredIterator_UnitTests.cpp.

 {
   // Need to use an unchecked iterator to make sure class thows
   int a_raw = 1;
   FilteredIterator<int*,SelectAll<int> > itr_begin(&a_raw, &a_raw, (&a_raw)+1);
   FilteredIterator<int*,SelectAll<int> > itr = itr_begin;
   TEST_THROW(--itr, RangeError);
   TEST_ITER_EQUALITY(itr, itr_begin);
   TEST_THROW(itr--, RangeError);
   TEST_ITER_EQUALITY(itr, itr_begin);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [161/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		removeObj_key_last
	)

Definition at line 413 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   typedef SIOVOCB::OrdinalIndex OI;
   typedef StringIndexedOrderedValueObjectContainer<OI>::ConstIterator ConstIterator;
   ECHO(StringIndexedOrderedValueObjectContainer<OI> oc);
   ECHO(oc.setObj("c", 1));
   ECHO(oc.setObj("a", 2));
   ECHO(oc.setObj("b", 3));
   TEST_EQUALITY_CONST(oc.numObjects(), 3);
   TEST_EQUALITY_CONST(oc.numStorage(), 3);
   ECHO(const OI &a = *oc.getObjPtr("a"));
   ECHO(oc.removeObj("b"));
   TEST_EQUALITY_CONST(oc.numObjects(), 2);
   TEST_EQUALITY_CONST(oc.numStorage(), 3);
   TEST_EQUALITY(&a, oc.getObjPtr("a").get());
   ECHO(ConstIterator itr = oc.begin());
   TEST_EQUALITY_CONST(itr->first, "c");
   TEST_EQUALITY_CONST(itr->second.idx, 1);
   TEST_EQUALITY_CONST(itr->isActive(), true);
   ECHO(++itr);
   TEST_EQUALITY_CONST(itr->first, "a");
   TEST_EQUALITY_CONST(itr->second.idx, 2);
   TEST_EQUALITY_CONST(itr->isActive(), true);
   ECHO(++itr);
   TEST_ITER_EQUALITY(itr, oc.end());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [162/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ObjectBuilder	,
		getNonconstParameterList
	)

Definition at line 414 of file ObjectBuilder_UnitTests.cpp.

                                                                     {
   const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>();
   ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
   RCP<ParameterList> pl = ob->getNonconstParameterList();
   TEST_EQUALITY_CONST( is_null(pl), true );
   pl = parameterList();
   pl->set("Object Type","None");
   TEST_NOTHROW( ob->setParameterList(pl) );
   {
     RCP<ParameterList> newPL = null;
     newPL = ob->getNonconstParameterList();
     TEST_EQUALITY_CONST( pl.get(), newPL.get() );
   }
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [163/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		get_default_then_change
	)

Definition at line 421 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
   ECHO(int &my_int = pl.get("my int", 3));
   TEST_EQUALITY_CONST(my_int, 3);
   TEST_EQUALITY_CONST(pl.get<int>("my int"), 3);
   ECHO(my_int = 5);
   TEST_EQUALITY_CONST(pl.get<int>("my int"), 5);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [164/224]

Teuchos::TEUCHOS_UNIT_TEST	(	TimeMonitor	,
		TimerLabelFiltering
	)

Definition at line 430 of file TimeMonitor_UnitTests.cpp.

   {
     using Teuchos::Array;
     using Teuchos::ParameterList;
     using Teuchos::parameterList;
     using Teuchos::RCP;
     using Teuchos::Time;
     typedef Array<std::string>::size_type size_type;
 
     // Filters to use in the test.
     Array<std::string> filters;
     filters.push_back ("Foo:");
     filters.push_back ("Bar:");
     filters.push_back ("Baz:");
 
     // All the timer labels.
     Array<std::string> labels;
     labels.push_back ("Foo: timer 1");
     labels.push_back ("Foo: timer 2");
     labels.push_back ("Foo: timer 3");
     labels.push_back ("Bar: timer 1");
     labels.push_back ("Bar: timer 2");
     labels.push_back ("Baz: timer 1");
     labels.push_back ("Xyzzy");
     labels.push_back ("This is not a pipe");
     labels.push_back ("You should not see this");
 
     Array<Array<std::string> > outLabels (3);
     // Label(s) that should be printed for filters[0]
     outLabels[0].push_back ("Foo: timer 1");
     outLabels[0].push_back ("Foo: timer 2");
     outLabels[0].push_back ("Foo: timer 3");
     // Label(s) that should be printed for filters[1]
     outLabels[1].push_back ("Bar: timer 1");
     outLabels[1].push_back ("Bar: timer 2");
     // Label(s) that should be printed for filters[2]
     outLabels[2].push_back ("Baz: timer 1");
 
     // Labels that should not be printed for any of the filters below.
     Array<std::string> otherLabels;
     otherLabels.push_back ("Xyzzy");
     otherLabels.push_back ("This is not a pipe");
     otherLabels.push_back ("You should not see this");
 
     Array<RCP<Time> > timers;
     for (size_type i = 0; i < labels.size (); ++i) {
       timers.push_back (TimeMonitor::getNewCounter (labels[i]));
     }
 
     // The actual number of operations in the loop is proportional to
     // the cube of the loop length.  Adjust the quantities below as
     // necessary to ensure the timer reports a nonzero elapsed time
     // for each of the invocations.
     const size_t loopLength = 25;
     for (int k = 0; k < 3; ++k) {
       for (size_type i = 0; i < timers.size (); ++i) {
         TimeMonitor timeMon (* timers[i]);
         slowLoop (loopLength);
       }
     }
 
     try {
       // FIXME (mfh 21 Aug 2012) We don't yet have a test ensuring that
       // the filter only selects at the beginning of the timer label.
 
       // Test for each filter.
       for (size_type i = 0; i < filters.size (); ++i) {
         { // Default (tabular) output format.
           std::ostringstream oss;
           RCP<ParameterList> reportParams =
             parameterList (* (TimeMonitor::getValidReportParameters ()));
           TimeMonitor::report (oss, filters[i], reportParams);
 
           // Echo output to the FancyOStream out (which is a standard unit
           // test argument).  Output should only appear in "show all test
           // details" mode.
           out << oss.str () << std::endl;
 
           // Check whether the labels that were supposed to be printed
           // were actually printed.
           for (size_type j = 0; j < outLabels[i].size(); ++j) {
             const size_t pos = oss.str ().find (outLabels[i][j]);
             TEST_INEQUALITY(pos, std::string::npos);
           }
 
           // Check whether the labels that were _not_ supposed to be
           // printed were actually printed.
           //
           // First, check the labels that should only be printed with
           // the other filters.
           for (size_type ii = 0; ii < outLabels.size(); ++ii) {
             if (ii != i) {
               for (size_type j = 0; j < outLabels[ii].size(); ++j) {
                 const size_t pos = oss.str ().find (outLabels[ii][j]);
                 TEST_EQUALITY(pos, std::string::npos);
               }
             }
           }
           // Next, check the labels that should not be printed for any
           // filters.
           for (size_type j = 0; j < otherLabels.size(); ++j) {
             const size_t pos = oss.str ().find (otherLabels[j]);
             TEST_EQUALITY(pos, std::string::npos);
           }
         }
 
         { // YAML output, compact style.
           std::ostringstream oss;
           RCP<ParameterList> reportParams =
             parameterList (* (TimeMonitor::getValidReportParameters ()));
           reportParams->set ("Report format", "YAML");
           reportParams->set ("YAML style", "compact");
           TimeMonitor::report (oss, filters[i], reportParams);
 
           // Echo output to the FancyOStream out (which is a standard unit
           // test argument).  Output should only appear in "show all test
           // details" mode.
           out << oss.str () << std::endl;
 
           // Check whether the labels that were supposed to be printed
           // were actually printed.
           for (size_type j = 0; j < outLabels[i].size(); ++j) {
             const size_t pos = oss.str ().find (outLabels[i][j]);
             TEST_INEQUALITY(pos, std::string::npos);
           }
 
           // Check whether the labels that were _not_ supposed to be
           // printed were actually printed.
           //
           // First, check the labels that should only be printed with
           // the other filters.
           for (size_type ii = 0; ii < outLabels.size(); ++ii) {
             if (ii != i) {
               for (size_type j = 0; j < outLabels[ii].size(); ++j) {
                 const size_t pos = oss.str ().find (outLabels[ii][j]);
                 TEST_EQUALITY(pos, std::string::npos);
               }
             }
           }
           // Next, check the labels that should not be printed for any
           // filters.
           for (size_type j = 0; j < otherLabels.size(); ++j) {
             const size_t pos = oss.str ().find (otherLabels[j]);
             TEST_EQUALITY(pos, std::string::npos);
           }
         }
 
         { // YAML output, spacious style.
           std::ostringstream oss;
           RCP<ParameterList> reportParams =
             parameterList (* (TimeMonitor::getValidReportParameters ()));
           reportParams->set ("Report format", "YAML");
           reportParams->set ("YAML style", "spacious");
           TimeMonitor::report (oss, filters[i], reportParams);
 
           // Echo output to the FancyOStream out (which is a standard unit
           // test argument).  Output should only appear in "show all test
           // details" mode.
           out << oss.str () << std::endl;
 
           // Check whether the labels that were supposed to be printed
           // were actually printed.
           for (size_type j = 0; j < outLabels[i].size(); ++j) {
             const size_t pos = oss.str ().find (outLabels[i][j]);
             TEST_INEQUALITY(pos, std::string::npos);
           }
 
           // Check whether the labels that were _not_ supposed to be
           // printed were actually printed.
           //
           // First, check the labels that should only be printed with
           // the other filters.
           for (size_type ii = 0; ii < outLabels.size(); ++ii) {
             if (ii != i) {
               for (size_type j = 0; j < outLabels[ii].size(); ++j) {
                 const size_t pos = oss.str ().find (outLabels[ii][j]);
                 TEST_EQUALITY(pos, std::string::npos);
               }
             }
           }
           // Next, check the labels that should not be printed for any
           // filters.
           for (size_type j = 0; j < otherLabels.size(); ++j) {
             const size_t pos = oss.str ().find (otherLabels[j]);
             TEST_EQUALITY(pos, std::string::npos);
           }
         }
       }
     }
     catch (...) {
       // Make sure to clear the counters, so that they don't pollute
       // the remaining tests.  (The Teuchos unit test framework may
       // catch any exceptions that the above code throws, but allow
       // the remaining tests to continue.)
       TimeMonitor::clearCounters ();
       throw;
     }
 
     // This sets up for the next unit test.
     TimeMonitor::clearCounters ();
   }

◆ TEUCHOS_UNIT_TEST() [165/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		remove_1
	)

Definition at line 432 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl;
   TEST_EQUALITY_CONST(pl.numParams(), 0);
   ECHO(pl.set("my int", 2));
   TEST_EQUALITY_CONST(pl.numParams(), 1);
   TEST_EQUALITY_CONST(pl.get<int>("my int"), 2);
   ECHO(const bool param_was_removed_1 = pl.remove("my int"));
   TEST_EQUALITY_CONST(param_was_removed_1, true);
   TEST_EQUALITY_CONST(pl.numParams(), 0);
   TEST_THROW(pl.get<int>("my int"), Exceptions::InvalidParameterName);
   TEST_THROW(pl.remove("my int"), Exceptions::InvalidParameterName);
   ECHO(const bool param_was_removed_2 = pl.remove("my int", false));
   TEST_EQUALITY_CONST(param_was_removed_2, false);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [166/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ObjectBuilder	,
		unsetParameterList
	)

Definition at line 437 of file ObjectBuilder_UnitTests.cpp.

                                                               {
   RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>();
   ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
   const RCP<ParameterList> pl = parameterList();
   pl->set("Object Type","None");
   ob->setParameterList(pl);
   RCP<Foo> foo = ob->create();
   TEST_EQUALITY_CONST( is_null(foo), true );
   RCP<ParameterList> newPL = ob->unsetParameterList();
   TEST_EQUALITY_CONST( pl.get(), newPL.get() ); // 1a.
   foo = ob->create();
   const RCP<FooA> fooA = rcp_dynamic_cast<FooA>(foo,false);
   TEST_EQUALITY_CONST( is_null(fooA), false ); // 1.
   ob->setParameterList(pl);
   pl->set("Hello","World");
   newPL = null;
 #ifdef TEUCHOS_DEBUG
   TEST_THROW( newPL = ob->unsetParameterList(), std::logic_error ); // 2.
   TEST_EQUALITY_CONST( is_null(newPL), true );
   TEST_THROW( ob = null, std::logic_error );
 #else // TEUCHOS_DEBUG
   TEST_NOTHROW( newPL = ob->unsetParameterList() );
   TEST_EQUALITY_CONST( pl.get(), newPL.get() ); // 1a.
   TEST_NOTHROW( ob = null );
 #endif // TEUCHOS_DEBUG
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [167/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		getNonconstObjPtr_idx_invalid
	)

Definition at line 442 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   //typedef StringIndexedOrderedValueObjectContainer<int>::Iterator Iterator; // unused
   ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
   ECHO(oc.setObj("a", 4));
   TEST_EQUALITY_CONST(*oc.getNonconstObjPtr(0), 4);
   TEST_THROW(oc.getNonconstObjPtr(-1), SIOVOCB::InvalidOrdinalIndexError);
   TEST_THROW(oc.getNonconstObjPtr(1), SIOVOCB::InvalidOrdinalIndexError);
   ECHO(oc.removeObj(0));
   TEST_THROW(oc.getNonconstObjPtr(0), SIOVOCB::InvalidOrdinalIndexError);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [168/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		get_nonexisting_sublist_default
	)

Definition at line 449 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl("Base");
   ECHO(pl.sublist("my sublist"));
   ECHO(const ParameterEntry &sublistParam = pl.getEntry("my sublist"));
   TEST_EQUALITY_CONST(sublistParam.isUsed(), false);
   TEST_EQUALITY_CONST(sublistParam.isList(), true);
   TEST_EQUALITY_CONST(sublistParam.isDefault(), false);
   TEST_EQUALITY_CONST(sublistParam.docString(), "");
   TEST_EQUALITY_CONST(sublistParam.getValue<ParameterList>(0).name(), "Base->my sublist");
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [169/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		getObjPtr_idx_invalid
	)

Definition at line 456 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   //typedef StringIndexedOrderedValueObjectContainer<int>::Iterator Iterator; // unused
   ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
   ECHO(oc.setObj("a", 4));
   TEST_EQUALITY_CONST(*oc.getObjPtr(0), 4);
   TEST_THROW(oc.getObjPtr(-1), SIOVOCB::InvalidOrdinalIndexError);
   TEST_THROW(oc.getObjPtr(1), SIOVOCB::InvalidOrdinalIndexError);
   ECHO(oc.removeObj(0));
   TEST_THROW(oc.getObjPtr(0), SIOVOCB::InvalidOrdinalIndexError);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [170/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		get_nonexisting_sublist_docString
	)

Definition at line 462 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl("Base");
   ECHO(pl.sublist("my sublist", false, "My great sublist"));
   ECHO(const ParameterEntry &sublistParam = pl.getEntry("my sublist"));
   TEST_EQUALITY_CONST(sublistParam.isUsed(), false);
   TEST_EQUALITY_CONST(sublistParam.isList(), true);
   TEST_EQUALITY_CONST(sublistParam.isDefault(), false);
   TEST_EQUALITY_CONST(sublistParam.docString(), "My great sublist");
   TEST_EQUALITY_CONST(sublistParam.getValue<ParameterList>(0).name(), "Base->my sublist");
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [171/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		removeObj_idx_invalid
	)

Definition at line 470 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   //typedef StringIndexedOrderedValueObjectContainer<int>::Iterator Iterator; // unused
   ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
   ECHO(oc.setObj("a", 4));
   TEST_EQUALITY_CONST(*oc.getObjPtr(0), 4);
   TEST_THROW(oc.removeObj(-1), SIOVOCB::InvalidOrdinalIndexError);
   TEST_THROW(oc.removeObj(1), SIOVOCB::InvalidOrdinalIndexError);
   TEST_EQUALITY_CONST(oc.numObjects(), 1);
   ECHO(oc.removeObj(0));
   TEST_EQUALITY_CONST(oc.numObjects(), 0);
   TEST_THROW(oc.removeObj(0), SIOVOCB::InvalidOrdinalIndexError);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [172/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ObjectBuilder	,
		getValidParameters
	)

Definition at line 471 of file ObjectBuilder_UnitTests.cpp.

                                                               {
   {
     const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>();
     ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
     const RCP<ParameterList> pl = parameterList();
     pl->set("Object Type","Foo B");
     TEST_THROW( ob->setParameterList(pl), std::logic_error ); // 2.
   }
   {
     const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>();
     ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
     ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo B");
     ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo C");
     const RCP<ParameterList> validPL = parameterList();
     validPL->set("Object Type","Foo C");
     validPL->sublist("Foo A").set("String","A");
     validPL->sublist("Foo B").set("String","B");
     validPL->sublist("Foo C").set("String","C");
     Array<std::string> validObjectNames;
     validObjectNames.push_back("None");
     validObjectNames.push_back("Foo A");
     validObjectNames.push_back("Foo B");
     validObjectNames.push_back("Foo C");
     const RCP<const StringToIntegralParameterEntryValidator<int> >
       objectValidator = rcp(
         new StringToIntegralParameterEntryValidator<int>(
           validObjectNames,"Object Type"
           )
         );
     validPL->set(
       "Object Type","Foo C"
       ,(std::string("Determines the type of Object object that will be built.\n")
         + "The parameters for each Object Type are specified in this sublist"
         ).c_str()
       ,objectValidator
       );
     const RCP<const ParameterList> pl = ob->getValidParameters();
     TEST_NOTHROW( pl->validateParameters(*validPL) ); // 4.
     validPL->set("Object Type","Foo A");
     TEST_NOTHROW( pl->validateParameters(*validPL) ); // 4.
     validPL->set("Object Type","Foo B");
     TEST_NOTHROW( pl->validateParameters(*validPL) ); // 4.
     validPL->set("Object Type","None");
     TEST_NOTHROW( pl->validateParameters(*validPL) ); // 4.
   }
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [173/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		get_nonexisting_sublist_mustAlreadyExist
	)

Definition at line 475 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl("Base");
   TEST_THROW(pl.sublist("my sublist", true), Exceptions::InvalidParameterName);
   // ToDo: Examine the actual structure of the error message
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [174/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Validators	,
		stringValidator
	)

Definition at line 477 of file Validator_UnitTest.cpp.

 {
     RCP<ParameterList> stringList = rcp(new ParameterList("String List"));
     Array<std::string> stringVals = tuple<std::string>("str1", "str2", "str3");
     RCP<StringValidator> stringVali = rcp(new StringValidator(stringVals));
     RCP<const Array<std::string> > valiVals = stringVali->validStringValues();
   /*bool local_success = true;
   for(int i =0; i<valiVals.size() ++i){
       TEST_ARRAY_ELE_EQUALITY(*valiVals, i, stringVals[i]);
   }
   if (local_success) out << "passed\n";
   else success = false;*/
   TEST_COMPARE_ARRAYS(*valiVals, stringVals);
     TEST_NOTHROW(stringList->set("String param1", "str1", "a string parameter", stringVali));
     TEST_THROW(stringList->set("String param2", "not in list", "a string parameter", stringVali),
     Exceptions::InvalidParameterValue);
     TEST_THROW(stringList->set("int param", 5, "a int parameter", stringVali),
     Exceptions::InvalidParameterType);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [175/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		get_existing_sublist_nonsublist
	)

Definition at line 483 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl("Base");
   ECHO(pl.set("my sublist", 1)); // Not a sublist!
   TEST_THROW(pl.sublist("my sublist"), Exceptions::InvalidParameterType);
   // ToDo: Examine the actual structure of the error message
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [176/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		getNonconstObjPtr_key_invalid
	)

Definition at line 486 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   //typedef StringIndexedOrderedValueObjectContainer<int>::Iterator Iterator; // unused
   ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
   ECHO(oc.setObj("a", 4));
   TEST_EQUALITY_CONST(*oc.getNonconstObjPtr("a"), 4);
   TEST_THROW(oc.getNonconstObjPtr("does_not_exist"), SIOVOCB::InvalidKeyError);
   ECHO(oc.removeObj("a"));
   TEST_THROW(oc.getNonconstObjPtr("a"), SIOVOCB::InvalidKeyError);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [177/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		get_existing_sublist_nonconst
	)

Definition at line 492 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl("Base");
   ECHO(pl.sublist("my sublist").set("my int", 2));
   ECHO(const int my_int = pl.sublist("my sublist").get<int>("my int"));
   TEST_EQUALITY_CONST(my_int, 2);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [178/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		getObjPtr_key_invalid
	)

Definition at line 499 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   //typedef StringIndexedOrderedValueObjectContainer<int>::Iterator Iterator; // unused
   ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
   ECHO(oc.setObj("a", 4));
   TEST_EQUALITY_CONST(*oc.getObjPtr("a"), 4);
   TEST_THROW(oc.getObjPtr("does_not_exist"), SIOVOCB::InvalidKeyError);
   ECHO(oc.removeObj("a"));
   TEST_THROW(oc.getObjPtr("a"), SIOVOCB::InvalidKeyError);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [179/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		get_existing_sublist_const
	)

Definition at line 501 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl("Base");
   ECHO(pl.sublist("my sublist").set("my int", 2));
   ECHO(const int my_int = getConst(pl).sublist("my sublist").get<int>("my int"));
   TEST_EQUALITY_CONST(my_int, 2);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [180/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Validators	,
		fileNameValidator
	)

Definition at line 501 of file Validator_UnitTest.cpp.

 {
     RCP<ParameterList> fileNameList = rcp(new ParameterList("Filename List"));
     RCP<FileNameValidator> fileNameVali = rcp(new FileNameValidator(true));
     TEST_ASSERT(fileNameVali->fileMustExist());
     fileNameVali->setFileMustExist(false);
     TEST_ASSERT(!fileNameVali->fileMustExist());
     TEST_NOTHROW(fileNameList->set("File name param", "../path", "file name parameter",
       fileNameVali));
     TEST_THROW(fileNameList->set("int param", 5, "int parameter", fileNameVali),
     Exceptions::InvalidParameterType);
     fileNameVali->setFileMustExist(true);
     TEST_NOTHROW(fileNameList->set("file name param", "testFile.txt", "a file name", fileNameVali));
     TEST_THROW(fileNameList->set("file name param", "doesntexist.txt", "a file name", fileNameVali),
     Exceptions::InvalidParameterValue);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [181/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		get_nonexisting_sublist_const
	)

Definition at line 510 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl("Base");
   TEST_THROW(getConst(pl).sublist("my sublist"), Exceptions::InvalidParameterName);
   // ToDo: Examine the actual structure of the error message
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [182/224]

Teuchos::TEUCHOS_UNIT_TEST	(	StringIndexedOrderedValueObjectContainer	,
		removeObj_key_invalid
	)

Definition at line 512 of file StringIndexedOrderedValueObjectContainer_UnitTests.cpp.

 {
   typedef StringIndexedOrderedValueObjectContainerBase SIOVOCB;
   //typedef StringIndexedOrderedValueObjectContainer<int>::Iterator Iterator; // unused
   ECHO(StringIndexedOrderedValueObjectContainer<int> oc);
   ECHO(oc.setObj("a", 4));
   TEST_EQUALITY_CONST(*oc.getObjPtr("a"), 4);
   TEST_THROW(oc.removeObj("does_not_exist"), SIOVOCB::InvalidKeyError);
   TEST_EQUALITY_CONST(oc.numObjects(), 1);
   ECHO(oc.removeObj("a"));
   TEST_EQUALITY_CONST(oc.numObjects(), 0);
   TEST_THROW(oc.removeObj("a"), SIOVOCB::InvalidKeyError);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [183/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		get_existing_sublist_const_nonsublist
	)

Definition at line 518 of file ParameterList_UnitTests.cpp.

 {
   ParameterList pl("Base");
   ECHO(pl.set("my sublist", 1)); // Not a sublist!
   TEST_THROW(getConst(pl).sublist("my sublist"), Exceptions::InvalidParameterType);
   // ToDo: Examine the actual structure of the error message
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [184/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Validators	,
		arrayValidators
	)

Definition at line 522 of file Validator_UnitTest.cpp.

 {
 
     /*
      * Testing StringArrayValidator.
      */
     RCP<ParameterList> stringList = rcp(new ParameterList("String List"));
     Array<std::string> stringVals = tuple<std::string>("str1", "str2", "str3");
     RCP<StringValidator> stringVali = rcp(new StringValidator(stringVals));
     RCP<ArrayStringValidator> stringArrayVali = rcp(new ArrayStringValidator(stringVali));
     TEST_ASSERT(stringVali.get() == stringArrayVali->getPrototype().get());
     Array<std::string> stringArray = tuple<std::string>("str2","str3","str1","str3","str2");
     TEST_NOTHROW(stringList->set("String Array Param", stringArray, "string array parameter", stringArrayVali));
     Array<std::string> badStringArray = tuple<std::string>("not valid","str3","str1","str3","str2");
     TEST_THROW(stringList->set("String Array Param", badStringArray, "string array parameter", stringArrayVali),
     Exceptions::InvalidParameterValue);
     TEST_THROW(stringList->set("Int param", 5, "int parameter", stringArrayVali),
     Exceptions::InvalidParameterType);
     Array<long> longArray = tuple<long>((long)5,(long)5,(long)3);
     TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", stringArrayVali),
     Exceptions::InvalidParameterType);
     
     /*
      * Testing Int ArrayValidator.
      */
     RCP<ParameterList> intList = rcp(new ParameterList("Int List"));
     RCP<EnhancedNumberValidator<int> > intVali = rcp(new EnhancedNumberValidator<int>(0, 10));
     RCP<ArrayNumberValidator<int> > intArrayVali = rcp(new ArrayNumberValidator<int>(intVali));
     TEST_ASSERT(intVali.get() == intArrayVali->getPrototype().get());
     Array<int> intArray = tuple<int>(1,4,2,5);
     TEST_NOTHROW(intList->set("int array param", intArray, "int array parameter", intArrayVali));
     Array<int> intBadArray = tuple<int>(11,4,2,5);
     TEST_THROW(intList->set("int bad array param", intBadArray, "int bad array parameter", intArrayVali),
     Exceptions::InvalidParameterValue);
     TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", intArrayVali),
     Exceptions::InvalidParameterType);
 
     /*
      * Testing Short ArrayValidator.
      */
     RCP<ParameterList> shortList = rcp(new ParameterList("Short List"));
     RCP<EnhancedNumberValidator<short> > shortVali =
     rcp(new EnhancedNumberValidator<short>(0, 10));
     RCP<ArrayNumberValidator<short> > shortArrayVali =
     rcp(new ArrayNumberValidator<short>(shortVali));
     TEST_ASSERT(shortVali.get() == shortArrayVali->getPrototype().get());
     Array<short> shortArray = tuple<short>(1,4,2,5);
     TEST_NOTHROW(shortList->set("short array param", shortArray, "short array parameter", shortArrayVali));
     Array<short> shortBadArray = tuple<short>(11,4,2,5);
     TEST_THROW(shortList->set("short bad array param", shortBadArray, "short bad array parameter", shortArrayVali),
     Exceptions::InvalidParameterValue);
     TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", shortArrayVali),
     Exceptions::InvalidParameterType);
 
     /*
      * Testing Float ArrayValidator.
      */
     RCP<ParameterList> floatList = rcp(new ParameterList("Float List"));
     RCP<EnhancedNumberValidator<float> > floatVali =
     rcp(new EnhancedNumberValidator<float>(0.0, 10.0));
     RCP<ArrayNumberValidator<float> > floatArrayVali =
     rcp(new ArrayNumberValidator<float>(floatVali));
     TEST_ASSERT(floatVali.get() == floatArrayVali->getPrototype().get());
     Array<float> floatArray = tuple<float>(1.0,4.0,2.0,5.0);
     TEST_NOTHROW(floatList->set("float array param", floatArray, "float array parameter", floatArrayVali));
     Array<float> floatBadArray = tuple<float>(11.0,4.0,2.0,5.0);
     TEST_THROW(floatList->set("float bad array param", floatBadArray, "float bad array parameter", floatArrayVali),
     Exceptions::InvalidParameterValue);
     TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", floatArrayVali),
     Exceptions::InvalidParameterType);
 
     /*
      * Testing Double ArrayValidator.
      */
     RCP<ParameterList> doubleList = rcp(new ParameterList("Double List"));
     RCP<EnhancedNumberValidator<double> > doubleVali =
     rcp(new EnhancedNumberValidator<double>(0.0, 10.0));
     RCP<ArrayNumberValidator<double> > doubleArrayVali =
     rcp(new ArrayNumberValidator<double>(doubleVali));
     TEST_ASSERT(doubleVali.get() == doubleArrayVali->getPrototype().get());
     Array<double> doubleArray = tuple<double>(1.0,4.0,2.0,5.0);
     TEST_NOTHROW(doubleList->set("double array param", doubleArray, "double array parameter", doubleArrayVali));
     Array<double> doubleBadArray = tuple<double>(11.0,4.0,2.0,5.0);
     TEST_THROW(doubleList->set("double bad array param", doubleBadArray, "double bad array parameter", doubleArrayVali),
     Exceptions::InvalidParameterValue);
     TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", doubleArrayVali),
     Exceptions::InvalidParameterType);
 
     /*
      * Testing FileName ArrayValidator.
      */
     RCP<ParameterList> fileNameList = rcp(new ParameterList("Filename List"));
     RCP<FileNameValidator> fileNameVali = rcp(new FileNameValidator(true));
     RCP<ArrayFileNameValidator> arrayFileNameVali = rcp(new ArrayFileNameValidator(fileNameVali));
     TEST_ASSERT(arrayFileNameVali->getPrototype().get() == fileNameVali.get());
     Array<std::string> fileNameArray = tuple<std::string>("testFile.txt", "testFile2.txt", "testFile3.txt");
     Array<std::string> fileNameBadArray = tuple<std::string>("doesnexist.txt", "testFile2.txt", "testFile3.txt");
     TEST_NOTHROW(fileNameList->set("File name array", fileNameArray, "file name array parameter", arrayFileNameVali));
     TEST_THROW(fileNameList->set("Bad File name array", fileNameBadArray, "bad file name array parameter", arrayFileNameVali),
     Exceptions::InvalidParameterValue);
     TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", arrayFileNameVali),
     Exceptions::InvalidParameterType);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [185/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ObjectBuilder	,
		usedParameters
	)

Definition at line 524 of file ObjectBuilder_UnitTests.cpp.

                                                           {
   const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>("Foo","Foo Type");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooB>(),"Foo B");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooC>(),"Foo C");
   {
     const RCP<ParameterList> pl = parameterList();
     ob->setParameterList(pl);
     const RCP<Foo> foo = ob->create("Foo A");
     TEST_EQUALITY_CONST( foo->getString(), "A" );
     TEST_EQUALITY_CONST( pl->isSublist("Foo A"), true ); // 1.
     TEST_EQUALITY_CONST( pl->sublist("Foo A").isParameter("String"), true ); // 1.
     const ParameterEntry& pe = pl->sublist("Foo A").getEntry("String");
     TEST_EQUALITY_CONST( pe.isUsed(), true ); // 1.
     TEST_EQUALITY_CONST( pe.isDefault(), true ); // 1.
     // verify the other sublists are missing
     TEST_EQUALITY_CONST( pl->isSublist("Foo B"), false ); // 1.
     TEST_EQUALITY_CONST( pl->isSublist("Foo C"), false ); // 1.
     ob->unsetParameterList();
   }
   {
     RCP<ParameterList> pl = parameterList();
     pl->setParameters(*ob->getValidParameters());
     pl->sublist("Foo A").set("String","AA");
     ob->setParameterList(pl);
     pl = null;
     const RCP<Foo> foo = ob->create("Foo A");
     TEST_EQUALITY_CONST( foo->getString(), "AA" );
     const RCP<const ParameterList> outPL = ob->getParameterList();
     TEST_EQUALITY_CONST( outPL->isSublist("Foo A"), true );
     TEST_EQUALITY_CONST( outPL->sublist("Foo A").isParameter("String"), true );
     const ParameterEntry& pe = outPL->sublist("Foo A").getEntry("String");
     TEST_EQUALITY_CONST( pe.isUsed(), true ); // 2.
     TEST_EQUALITY_CONST( pe.isDefault(), false ); // 2.
     // verify the other sublists are unused
     TEST_EQUALITY_CONST( outPL->sublist("Foo B").getEntry("String").isUsed(), false ); // 2.
     TEST_EQUALITY_CONST( outPL->sublist("Foo C").getEntry("String").isUsed(), false ); // 2.
     ob->unsetParameterList();
   }
 }

◆ TEUCHOS_UNIT_TEST() [186/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		sublist_add_2
	)

Definition at line 527 of file ParameterList_UnitTests.cpp.

 {
   ParameterList PL_Main("PL_Main");
   const std::string Direction_Doc = "This sublist controls how direction is computed.";
   ParameterList& PL_Direction = PL_Main.sublist("Direction", false, Direction_Doc);
   ParameterList& PL_LineSearch = PL_Main.sublist("Line Search");
   out << "PL_Main=\n" << PL_Main << "\n";
   TEST_EQUALITY_CONST(PL_Main.name(), "PL_Main");
   TEST_EQUALITY_CONST(PL_Main.isSublist("Direction"), true);
   TEST_EQUALITY_CONST(PL_Main.isSublist("Line Search"), true);
   ECHO(const ParameterList& PL_Direction_2 = getConst(PL_Main).sublist("Direction"));
   TEST_EQUALITY(&PL_Direction, &PL_Direction_2);
   ECHO(const ParameterList& PL_LineSearch_2 = getConst(PL_Main).sublist("Line Search"));
   TEST_EQUALITY(&PL_LineSearch, &PL_LineSearch_2);
   TEST_EQUALITY_CONST(getConst(PL_Main).sublist("Direction").name(), "PL_Main->Direction");
   TEST_EQUALITY_CONST(PL_Direction.name(), "PL_Main->Direction");
   TEST_EQUALITY_CONST(PL_LineSearch.name(), "PL_Main->Line Search");
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [187/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Validator	,
		existingPrototypeTest
	)

Definition at line 543 of file Validator_SerializationTest.cpp.

                                                            {
   ParameterList pl("ExsitingPrototypeList");
   RCP<StringValidator> stringVali = rcp(new StringValidator());
   RCP<ArrayValidator<StringValidator, std::string> > arrayStringVali
     = rcp(new ArrayValidator<StringValidator, std::string>(stringVali));
   Array<std::string> strArray = tuple<std::string>("blah", "blah", "blah");
   pl.set("string param", "hi", "a string param", stringVali);
   pl.set("string array param", strArray,
     "a string array parameter", arrayStringVali);
   RCP<ParameterList> readInPL = writeThenReadPL(pl);
   RCP<const ArrayValidator<StringValidator, std::string> >
     inArrayValidator =
     rcp_dynamic_cast<const ArrayValidator<StringValidator, std::string> >(
       readInPL->getEntry("string array param").validator(), true);
   TEST_ASSERT(readInPL->getEntry("string param").validator()
     == inArrayValidator->getPrototype());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [188/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		sublist_scenario_1
	)

Definition at line 547 of file ParameterList_UnitTests.cpp.

 {
   // This is the scenario in the orginal testing program
   ParameterList PL_Main("PL_Main");
   const std::string Direction_Doc = "This sublist controls how direction is computed.";
   ParameterList &PL_Direction = PL_Main.sublist("Direction", false, Direction_Doc);
   ParameterList &PL_Newton = PL_Direction.sublist("Newton");
   ParameterList &PL_LinSol = PL_Newton.sublist("Linear Solver");
   ParameterList &PL_LineSearch = PL_Main.sublist("Line Search");
   out << "PL_Main=\n" << PL_Main << "\n";
   TEST_EQUALITY_CONST(PL_Main.name(), "PL_Main");
   TEST_EQUALITY_CONST(PL_Main.isSublist("Direction"), true);
   ECHO(const ParameterList& PL_Direction_2 = getConst(PL_Main).sublist("Direction"));
   TEST_EQUALITY(&PL_Direction, &PL_Direction_2);
   TEST_EQUALITY_CONST(getConst(PL_Main).sublist("Direction").name(), "PL_Main->Direction");
   TEST_EQUALITY_CONST(PL_Direction.name(), "PL_Main->Direction");
   TEST_EQUALITY_CONST(PL_Direction.isSublist("Newton"), true);
   TEST_EQUALITY_CONST(PL_Newton.isSublist("Linear Solver"), true);
   TEST_EQUALITY_CONST(PL_Newton.name(), "PL_Main->Direction->Newton");
   TEST_EQUALITY_CONST(PL_Newton.isSublist("Linear Solver"), true);
   TEST_EQUALITY_CONST(PL_LinSol.name(), "PL_Main->Direction->Newton->Linear Solver");
   TEST_EQUALITY_CONST(PL_Main.isSublist("Line Search"), true);
   TEST_EQUALITY_CONST(PL_LineSearch.name(), "PL_Main->Line Search");
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [189/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ObjectBuilder	,
		setDefaultObject_withOneUsePL
	)

Definition at line 565 of file ObjectBuilder_UnitTests.cpp.

                                                                           {
   const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>("Foo","Foo Type");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooB>(),"Foo B");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooC>(),"Foo C");
   {
     const RCP<ParameterList> pl = parameterList();
     ob->setParameterList(pl);
     const RCP<Foo> foo = ob->create();
     RCP<FooC> fooC = Teuchos::rcp_dynamic_cast<FooC>(foo,false);
     TEST_ASSERT( !is_null(fooC) );
   }
   {
     const RCP<ParameterList> pl = parameterList();
     ob->setParameterList(pl);
     ob->setDefaultObject("Foo A");
     const RCP<Foo> foo = ob->create();
     RCP<FooA> fooA = Teuchos::rcp_dynamic_cast<FooA>(foo,false);
     TEST_ASSERT( !is_null(fooA) );
   }
   {
     const RCP<ParameterList> pl = parameterList();
     ob->setParameterList(pl);
     ob->setDefaultObject("None");
     const RCP<Foo> foo = ob->create();
     TEST_ASSERT( is_null(foo) );
   }
   {
 #ifdef TEUCHOS_DEBUG
     TEST_THROW(ob->setDefaultObject("Foo D"), std::logic_error);
 #else
     ob->setDefaultObject("Foo D");
     TEST_THROW(ob->getValidParameters(), std::logic_error);
 #endif // TEUCHOS_DEBUG
   }
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [190/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		copy_constructor
	)

Definition at line 573 of file ParameterList_UnitTests.cpp.

 {
   ECHO(ParameterList pl1("A"));
   ECHO(pl1.set("my int", 2));
   ECHO(ParameterList pl2(pl1));
   TEST_EQUALITY_CONST(pl2.name(), "A");
   TEST_EQUALITY_CONST(pl2.get<int>("my int"), 2);
 }

◆ TEUCHOS_UNIT_TEST() [191/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		assignment_operator
	)

Definition at line 583 of file ParameterList_UnitTests.cpp.

 {
   ECHO(ParameterList pl1("A"));
   ECHO(pl1.set("my int", 2));
   ECHO(ParameterList pl2);
   ECHO(const ParameterList &pl2_ref = pl2 = pl1);
   TEST_EQUALITY_CONST(&pl2_ref, &pl2);
   TEST_EQUALITY_CONST(pl2.name(), "A");
   TEST_EQUALITY_CONST(pl2.get<int>("my int"), 2);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [192/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		iterator_params
	)

Definition at line 595 of file ParameterList_UnitTests.cpp.

 {
   typedef ParameterList::ConstIterator ConstIter;
   ParameterList pl;
   pl.set("c", 1);
   pl.set("a", 2);
   pl.set("b", 3);
   ConstIter pl_itr = pl.begin();
   TEST_EQUALITY_CONST(pl_itr->first, "c");
   TEST_EQUALITY_CONST(pl_itr->second.getValue<int>(0), 1);
   ECHO(++pl_itr);
   TEST_EQUALITY_CONST(pl_itr->first, "a");
   TEST_EQUALITY_CONST(pl_itr->second.getValue<int>(0), 2);
   ECHO(++pl_itr);
   TEST_EQUALITY_CONST(pl_itr->first, "b");
   TEST_EQUALITY_CONST(pl_itr->second.getValue<int>(0), 3);
   ECHO(++pl_itr);
   TEST_ITER_EQUALITY(pl_itr, pl.end());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [193/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ObjectBuilder	,
		setDefaultObject_withMultipleUsePL
	)

Definition at line 601 of file ObjectBuilder_UnitTests.cpp.

                                                                                {
   const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>("Foo","Foo Type");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooB>(),"Foo B");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooC>(),"Foo C");
   const RCP<ParameterList> pl = parameterList();
   ob->setParameterList(pl);
   {
     const RCP<Foo> foo = ob->create();
     RCP<FooC> fooC = Teuchos::rcp_dynamic_cast<FooC>(foo,false);
     TEST_ASSERT( !is_null(fooC) );
     // Note:  At this point, pl contains "Foo Type = Foo C"
     // And this pl was set on the ObjectBuilder, so defaultObject does no good.
   }
   {
     ob->setDefaultObject("Foo A");
     const RCP<Foo> foo = ob->create();
     RCP<FooA> fooA = Teuchos::rcp_dynamic_cast<FooA>(foo,false);
     TEST_ASSERT( is_null(fooA) );
   }
   {
     ob->setDefaultObject("None");
     const RCP<Foo> foo = ob->create();
     TEST_ASSERT( !is_null(foo) );
   }
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [194/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		testTwoDRowDependency
	)

Test the TwoDRowDependency.

Definition at line 608 of file Dependencies_UnitTests.cpp.

                                                               {
     RCP<ParameterList> My_deplist = RCP<ParameterList>(new ParameterList);
     RCP<DependencySheet> depSheet1 =
     RCP<DependencySheet>(new DependencySheet);
 
     ParameterList
     rowNumDepList = My_deplist->sublist(
     "2D Row Depdency List", false,
     "2D Row Dependecy testing list.");
     rowNumDepList.set("Num rows", 10, "num rows setter");
   TwoDArray<double> variableRowsArray(11,2,16.5);
     RCP<EnhancedNumberValidator<double> >
     varRowArrayVali = RCP<EnhancedNumberValidator<double> >(
         new EnhancedNumberValidator<double>(10,50,4)
     );
     rowNumDepList.set(
     "Variable Row Array", variableRowsArray, "variable row array",
       RCP<TwoDArrayNumberValidator<double> >(
       new TwoDArrayNumberValidator<double>(varRowArrayVali)));
 
     RCP<TwoDRowDependency<int, double> >
       arrayRowDep = rcp(
         new TwoDRowDependency<int, double>(
           rowNumDepList.getEntryRCP("Num rows"),
             rowNumDepList.getEntryRCP("Variable Row Array") ,
       rcp(new AdditionFunction<int>(1))
         )
     );
     depSheet1->addDependency(arrayRowDep);
   TwoDArray<double> curArray =
     rowNumDepList.get<TwoDArray<double> >("Variable Row Array");
     TEST_EQUALITY_CONST(curArray.getNumRows(),11);
     rowNumDepList.set("Num rows", 12);
     arrayRowDep()->evaluate();
   curArray =
     rowNumDepList.get<TwoDArray<double> >("Variable Row Array");
     TEST_EQUALITY_CONST(curArray.getNumRows(),13);
     rowNumDepList.set("Num rows", -2);
     TEST_THROW(arrayRowDep()->evaluate(),
     Exceptions::InvalidParameterValue);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [195/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		iterator_params_sublists
	)

Definition at line 616 of file ParameterList_UnitTests.cpp.

 {
   typedef ParameterList::ConstIterator ConstIter;
   ParameterList pl("base");
   pl.set("c", 1);
   pl.sublist("a");
   pl.set("b", 3);
   ConstIter pl_itr = pl.begin();
   TEST_EQUALITY_CONST(pl_itr->first, "c");
   TEST_EQUALITY_CONST(pl_itr->second.getValue<int>(0), 1);
   ECHO(++pl_itr);
   TEST_EQUALITY_CONST(pl_itr->first, "a");
   TEST_EQUALITY_CONST(pl_itr->second.getValue<ParameterList>(0).name(), "base->a");
   ECHO(++pl_itr);
   TEST_EQUALITY_CONST(pl_itr->first, "b");
   TEST_EQUALITY_CONST(pl_itr->second.getValue<int>(0), 3);
   ECHO(++pl_itr);
   TEST_ITER_EQUALITY(pl_itr, pl.end());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [196/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_ObjectBuilder	,
		setDefaultObject_withoutPL
	)

Definition at line 628 of file ObjectBuilder_UnitTests.cpp.

                                                                        {
   const RCP<ObjectBuilder<Foo> > ob = objectBuilder<Foo>("Foo","Foo Type");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooA>(),"Foo A");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooB>(),"Foo B");
   ob->setObjectFactory(abstractFactoryStd<Foo,FooC>(),"Foo C");
   {
     const RCP<Foo> foo = ob->create();
     RCP<FooC> fooC = Teuchos::rcp_dynamic_cast<FooC>(foo,false);
     TEST_ASSERT( !is_null(fooC) );
   }
   {
     ob->setDefaultObject("Foo A");
     const RCP<Foo> foo = ob->create();
     RCP<FooA> fooA = Teuchos::rcp_dynamic_cast<FooA>(foo,false);
     TEST_ASSERT( !is_null(fooA) );
   }
   {
     ob->setDefaultObject("None");
     const RCP<Foo> foo = ob->create();
     TEST_ASSERT( is_null(foo) );
   }
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [197/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Validators	,
		twoDArrayValidators
	)

Definition at line 629 of file Validator_UnitTest.cpp.

 {
 
     /*
      * Testing StringArrayValidator.
      */
     RCP<ParameterList> stringList = rcp(new ParameterList("String List"));
     Array<std::string> stringVals = tuple<std::string>("str1", "str2", "str3");
     RCP<StringValidator> stringVali = rcp(new StringValidator(stringVals));
     RCP<TwoDArrayStringValidator> stringArrayVali =
     rcp(new TwoDArrayStringValidator(stringVali));
     TEST_ASSERT(stringVali.get() == stringArrayVali->getPrototype().get());
     TwoDArray<std::string> stringArray(2,2);
   stringArray(0,0) = "str2";
   stringArray(0,1) = "str1";
   stringArray(1,0) = "str3";
   stringArray(1,1) = "str2";
     TEST_NOTHROW(stringList->set("String Array Param", stringArray, "string array parameter", stringArrayVali));
     TwoDArray<std::string> badStringArray(2,2);
   badStringArray(0,0) = "str2";
   badStringArray(0,1) = "str1";
   badStringArray(1,0) = "str3";
   badStringArray(1,1) = "not valid";
     TEST_THROW(stringList->set("String Array Param", badStringArray, "string array parameter", stringArrayVali),
     Exceptions::InvalidParameterValue);
     TEST_THROW(stringList->set("Int param", 5, "int parameter", stringArrayVali),
     Exceptions::InvalidParameterType);
     TwoDArray<long> longArray(2,2);
   longArray(0,0) = (long)5;
   longArray(0,1) = (long)4;
   longArray(1,0) = (long)9;
   longArray(1,1) = (long)1;
     TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", stringArrayVali),
     Exceptions::InvalidParameterType);
     
     /*
      * Testing Int ArrayValidator.
      */
     RCP<ParameterList> intList = rcp(new ParameterList("Int List"));
     RCP<EnhancedNumberValidator<int> > intVali = rcp(new EnhancedNumberValidator<int>(0, 10));
     RCP<TwoDArrayNumberValidator<int> > intArrayVali =
     rcp(new TwoDArrayNumberValidator<int>(intVali));
     TEST_ASSERT(intVali.get() == intArrayVali->getPrototype().get());
     TwoDArray<int> intArray(2,2);
   intArray(0,0) = 1;
   intArray(0,1) = 4;
   intArray(1,0) = 2;
   intArray(1,1) = 5;
     TEST_NOTHROW(intList->set("int array param", intArray, "int array parameter", intArrayVali));
     TwoDArray<int> intBadArray(2,2);
   intBadArray(0,0) = 11;
   intBadArray(0,1) = 4;
   intBadArray(1,0) = 2;
   intBadArray(1,1) = 5;
     TEST_THROW(intList->set("int bad array param", intBadArray, "int bad array parameter", intArrayVali),
     Exceptions::InvalidParameterValue);
     TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", intArrayVali),
     Exceptions::InvalidParameterType);
 
     /*
      * Testing Short ArrayValidator.
      */
     RCP<ParameterList> shortList = rcp(new ParameterList("Short List"));
     RCP<EnhancedNumberValidator<short> > shortVali =
     rcp(new EnhancedNumberValidator<short>(0, 10));
     RCP<TwoDArrayNumberValidator<short> > shortArrayVali =
     rcp(new TwoDArrayNumberValidator<short>(shortVali));
     TEST_ASSERT(shortVali.get() == shortArrayVali->getPrototype().get());
     TwoDArray<short> shortArray(2,2);
   shortArray(0,0) = 1;
   shortArray(0,1) = 4;
   shortArray(1,0) = 2;
   shortArray(1,1) = 5;
     TEST_NOTHROW(shortList->set("short array param", shortArray, "short array parameter", shortArrayVali));
     TwoDArray<short> shortBadArray(2,2);
   shortBadArray(0,0) = 11;
   shortBadArray(0,1) = 4;
   shortBadArray(1,0) = 2;
   shortBadArray(1,1) = 5;
     TEST_THROW(shortList->set("short bad array param", shortBadArray, "short bad array parameter", shortArrayVali),
     Exceptions::InvalidParameterValue);
     TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", shortArrayVali),
     Exceptions::InvalidParameterType);
 
     /*
      * Testing Float ArrayValidator.
      */
     RCP<ParameterList> floatList = rcp(new ParameterList("Float List"));
     RCP<EnhancedNumberValidator<float> > floatVali =
     rcp(new EnhancedNumberValidator<float>(0.0, 10.0));
     RCP<TwoDArrayNumberValidator<float> > floatArrayVali =
     rcp(new TwoDArrayNumberValidator<float>(floatVali));
     TEST_ASSERT(floatVali.get() == floatArrayVali->getPrototype().get());
     TwoDArray<float> floatArray(2,2);
   floatArray(0,0) = 1.0;
   floatArray(0,1) = 4.0;
   floatArray(1,0) = 5.0;
   floatArray(1,1) = 2.0;
     TEST_NOTHROW(floatList->set("float array param", floatArray, "float array parameter", floatArrayVali));
     TwoDArray<float> floatBadArray(2,2);
   floatBadArray(0,0) = 11.0;
   floatBadArray(0,1) = 4.0;
   floatBadArray(1,0) = 5.0;
   floatBadArray(1,1) = 2.0;
     TEST_THROW(floatList->set("float bad array param", floatBadArray, "float bad array parameter", floatArrayVali),
     Exceptions::InvalidParameterValue);
     TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", floatArrayVali),
     Exceptions::InvalidParameterType);
 
     /*
      * Testing Double ArrayValidator.
      */
     RCP<ParameterList> doubleList = rcp(new ParameterList("Double List"));
     RCP<EnhancedNumberValidator<double> > doubleVali =
     rcp(new EnhancedNumberValidator<double>(0.0, 10.0));
     RCP<TwoDArrayNumberValidator<double> > doubleArrayVali =
     rcp(new TwoDArrayNumberValidator<double>(doubleVali));
     TEST_ASSERT(doubleVali.get() == doubleArrayVali->getPrototype().get());
     TwoDArray<double> doubleArray(2,2);
   doubleArray(0,0) = 1.0;
   doubleArray(0,1) = 4.0;
   doubleArray(1,0) = 5.0;
   doubleArray(1,1) = 2.0;
     TEST_NOTHROW(doubleList->set("double array param", doubleArray, "double array parameter", doubleArrayVali));
     TwoDArray<double> doubleBadArray(2,2);
   doubleBadArray(0,0) = 11.0;
   doubleBadArray(0,1) = 4.0;
   doubleBadArray(1,0) = 5.0;
   doubleBadArray(1,1) = 2.0;
     TEST_THROW(doubleList->set("double bad array param", doubleBadArray, "double bad array parameter", doubleArrayVali),
     Exceptions::InvalidParameterValue);
     TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", doubleArrayVali),
     Exceptions::InvalidParameterType);
 
     /*
      * Testing FileName ArrayValidator.
      */
     RCP<ParameterList> fileNameList = rcp(new ParameterList("Filename List"));
     RCP<FileNameValidator> fileNameVali = rcp(new FileNameValidator(true));
     RCP<TwoDArrayFileNameValidator> arrayFileNameVali =
     rcp(new TwoDArrayFileNameValidator(fileNameVali));
     TEST_ASSERT(arrayFileNameVali->getPrototype().get() == fileNameVali.get());
     TwoDArray<std::string> fileNameArray(2,2);
   fileNameArray(0,0) = "testFile.txt";
   fileNameArray(0,1) = "testFile2.txt";
   fileNameArray(1,0) = "testFile3.txt";
   fileNameArray(1,1) = "testFile.txt";
     TwoDArray<std::string> fileNameBadArray(2,2);
   fileNameBadArray(0,0) = "doesntexist.txt";
   fileNameBadArray(0,1) = "testFile2.txt";
   fileNameBadArray(1,0) = "testFile3.txt";
   fileNameBadArray(1,1) = "testFile.txt";
     TEST_NOTHROW(fileNameList->set("File name array", fileNameArray, "file name array parameter", arrayFileNameVali));
     TEST_THROW(fileNameList->set("Bad File name array", fileNameBadArray, "bad file name array parameter", arrayFileNameVali),
     Exceptions::InvalidParameterValue);
     TEST_THROW(stringList->set("Long array param", longArray, "long array parameter", arrayFileNameVali),
     Exceptions::InvalidParameterType);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [198/224]

Teuchos::TEUCHOS_UNIT_TEST	(	TimeMonitor	,
		FUNC_TIME_MONITOR_tested
	)

Definition at line 639 of file TimeMonitor_UnitTests.cpp.

   {
     using Teuchos::ParameterList;
     using Teuchos::parameterList;
     using Teuchos::RCP;
 
     func_time_monitor2 ();
 
     {
       std::ostringstream oss;
       TimeMonitor::summarize (oss);
 
       // Echo summarize() output to the FancyOStream out (which is a
       // standard unit test argument).  Output should only appear in
       // show-all-test-details mode.
       out << oss.str() << std::endl;
 
       const size_t substr_i = oss.str().find ("FUNC_TIME_MONITOR2");
       TEST_INEQUALITY(substr_i, std::string::npos);
       const size_t substr_inner_i = oss.str().find ("FUNC_TIME_MONITOR2_inner");
       TEST_INEQUALITY(substr_inner_i, std::string::npos);
     }
 
     { // Repeat test for YAML output, compact style.
       std::ostringstream oss;
       RCP<ParameterList> reportParams =
         parameterList (* (TimeMonitor::getValidReportParameters ()));
       reportParams->set ("Report format", "YAML");
       reportParams->set ("YAML style", "compact");
       TimeMonitor::report (oss, reportParams);
 
       // Echo output to the FancyOStream out (which is a standard unit
       // test argument).  Output should only appear in "show all test
       // details" mode.
       out << oss.str () << std::endl;
 
       const size_t substr_i = oss.str().find ("FUNC_TIME_MONITOR2");
       TEST_INEQUALITY(substr_i, std::string::npos);
       const size_t substr_inner_i = oss.str().find ("FUNC_TIME_MONITOR2_inner");
       TEST_INEQUALITY(substr_inner_i, std::string::npos);
     }
 
     { // Repeat test for YAML output, spacious style.
       std::ostringstream oss;
       RCP<ParameterList> reportParams =
         parameterList (* (TimeMonitor::getValidReportParameters ()));
       reportParams->set ("Report format", "YAML");
       reportParams->set ("YAML style", "spacious");
       TimeMonitor::report (oss, reportParams);
 
       // Echo output to the FancyOStream out (which is a standard unit
       // test argument).  Output should only appear in "show all test
       // details" mode.
       out << oss.str () << std::endl;
 
       const size_t substr_i = oss.str().find ("FUNC_TIME_MONITOR2");
       TEST_INEQUALITY(substr_i, std::string::npos);
       const size_t substr_inner_i = oss.str().find ("FUNC_TIME_MONITOR2_inner");
       TEST_INEQUALITY(substr_inner_i, std::string::npos);
     }
 
     // This sets up for the next unit test.
     TimeMonitor::clearCounters ();
   }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [199/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		operatorEqualityWithEmpty
	)

Definition at line 641 of file ParameterList_UnitTests.cpp.

 {
   // An empty list should not be equal to a full list
   ParameterList A;
   ParameterList B;
   TEST_ASSERT( A == B );
   A.set("Hello","World");
   TEST_ASSERT( A != B );
   B.set("Hello","World");
   TEST_ASSERT( A == B );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [200/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		testTwoDColDependency
	)

Test the TwoDColDependency.

Definition at line 653 of file Dependencies_UnitTests.cpp.

                                                               {
     RCP<ParameterList> My_deplist = RCP<ParameterList>(new ParameterList);
     RCP<DependencySheet> depSheet1 =
     RCP<DependencySheet>(new DependencySheet);
 
     ParameterList
     colNumDepList = My_deplist->sublist(
     "2D Col Depdency List", false,
     "2D Col Dependecy testing list.");
     colNumDepList.set("Num cols", 2, "num cols setter");
   TwoDArray<double> variableColsArray(11,3,16.5);
     RCP<EnhancedNumberValidator<double> >
     varColArrayVali = RCP<EnhancedNumberValidator<double> >(
         new EnhancedNumberValidator<double>(10,50,4)
     );
     colNumDepList.set(
     "Variable Col Array", variableColsArray, "variable col array",
       RCP<TwoDArrayNumberValidator<double> >(
       new TwoDArrayNumberValidator<double>(varColArrayVali)));
 
     RCP<TwoDColDependency<int, double> >
       arrayColDep = rcp(
         new TwoDColDependency<int, double>(
           colNumDepList.getEntryRCP("Num cols"),
             colNumDepList.getEntryRCP("Variable Col Array") ,
       rcp(new AdditionFunction<int>(1))
         )
     );
     depSheet1->addDependency(arrayColDep);
   TwoDArray<double> curArray =
     colNumDepList.get<TwoDArray<double> >("Variable Col Array");
     TEST_EQUALITY_CONST(curArray.getNumCols(),3);
     colNumDepList.set("Num cols", 4);
     arrayColDep()->evaluate();
   curArray =
     colNumDepList.get<TwoDArray<double> >("Variable Col Array");
     TEST_EQUALITY_CONST(curArray.getNumCols(),5);
     colNumDepList.set("Num cols", -2);
     TEST_THROW(arrayColDep()->evaluate(),
     Exceptions::InvalidParameterValue);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [201/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		operatorEqualityDifferentSublistNames
	)

Definition at line 654 of file ParameterList_UnitTests.cpp.

 {
   // Sublists with different names should not be equal
   ParameterList A;
   ParameterList B;
   A.sublist("Bob");
   B.sublist("Tom");
   TEST_ASSERT( A != B );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [202/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		operatorEqualityDifferentLengths
	)

Definition at line 665 of file ParameterList_UnitTests.cpp.

 {
   ParameterList A;
   ParameterList B;
   A.set("A","a");
   A.set("B","b");
   A.set("C","c");
   A.print(out);
 
   B.set("A","a");
   B.set("B","b");
   B.print(out);
 
   TEST_ASSERT( A != B );
 
   B.set("C","c");
   TEST_ASSERT( A == B );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [203/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		haveSameValuesWithEmpty
	)

Definition at line 685 of file ParameterList_UnitTests.cpp.

 {
   ParameterList A;
   ParameterList B;
   TEST_ASSERT( haveSameValues(A,B) );
   A.set("Hello","World");
   TEST_ASSERT( !haveSameValues(A,B) );
   B.set("Hello","World");
   TEST_ASSERT( haveSameValues(A,B) );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [204/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		haveSameValuesDifferentSublistNames
	)

Definition at line 697 of file ParameterList_UnitTests.cpp.

 {
   ParameterList A;
   ParameterList B;
   A.sublist("Smith").set("People",4);
   B.sublist("Jones").set("People",4);
   TEST_ASSERT( !haveSameValues(A,B) ); // sublist names matter
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [205/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		testArrayLengthDep
	)

Test the ArrayLengthDependency.

Definition at line 699 of file Dependencies_UnitTests.cpp.

                                                            {
     RCP<ParameterList> My_deplist = RCP<ParameterList>(new ParameterList);
     RCP<DependencySheet> depSheet1 =
     RCP<DependencySheet>(new DependencySheet);
 
     ParameterList
     numberArrayLengthDepList = My_deplist->sublist(
     "Number Array Length Dependency List", false,
     "Number Array Length Dependecy testing list.");
     numberArrayLengthDepList.set("Array Length", 10, "array length setter");
     Array<double> variableLengthArray(11,23.0);
     RCP<EnhancedNumberValidator<double> >
     varLengthArrayVali = RCP<EnhancedNumberValidator<double> >(
         new EnhancedNumberValidator<double>(10,50,4)
     );
     numberArrayLengthDepList.set(
     "Variable Length Array", variableLengthArray, "variable length array",
       RCP<ArrayNumberValidator<double> >(
       new ArrayNumberValidator<double>(varLengthArrayVali)));
 
     RCP<NumberArrayLengthDependency<int, double> >
       arrayLengthDep(
         new NumberArrayLengthDependency<int, double>(
             numberArrayLengthDepList.getEntryRCP("Array Length"),
             numberArrayLengthDepList.getEntryRCP("Variable Length Array"),
       rcp(new AdditionFunction<int>(1))
         )
     );
     depSheet1->addDependency(arrayLengthDep);
   Array<double> curArray =
     numberArrayLengthDepList.get<Array<double> >("Variable Length Array");
     TEST_ASSERT(curArray.length() ==11);
     numberArrayLengthDepList.set("Array Length", 12);
     arrayLengthDep()->evaluate();
   curArray =
     numberArrayLengthDepList.get<Array<double> >("Variable Length Array");
   out << curArray.length() << std::endl;
     TEST_ASSERT(curArray.length() ==13);
     numberArrayLengthDepList.set("Array Length", -2);
     TEST_THROW(arrayLengthDep()->evaluate(),
     Exceptions::InvalidParameterValue);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [206/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		validateAgainstSelf
	)

Definition at line 707 of file ParameterList_UnitTests.cpp.

 {
   ParameterList PL_Main = createMainPL();
   ParameterList PL_Main_valid = createValidMainPL();
   TEST_NOTHROW(PL_Main.validateParameters(PL_Main_valid));
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [207/224]

Teuchos::TEUCHOS_UNIT_TEST	(	TimeMonitor	,
		SUMMARIZE_diffTimerSets
	)

Definition at line 711 of file TimeMonitor_UnitTests.cpp.

   {
     RCP<const Comm<int> > comm = Teuchos::DefaultComm<int>::getComm ();
     const int numProcs = comm->getSize ();
     const int myRank = comm->getRank ();
 
     // If MPI has not been initialized, turn the MPI communicator into
     // a "serial" communicator.  This may not be necessary when using
     // the Teuchos Unit Test Framework.
 #ifdef HAVE_MPI
     {
       int mpiHasBeenInitialized = 0;
       MPI_Initialized (&mpiHasBeenInitialized);
       if (! mpiHasBeenInitialized) {
         comm = Teuchos::DefaultComm<int>::getDefaultSerialComm (null);
       }
     }
 #endif // HAVE_MPI
 
     // Store the output of TimeMonitor::summarize() here.
     std::ostringstream oss;
 
     // Timer A gets created on all MPI processes.
     // Timer B only gets created on Proc 0.
     RCP<Time> timerA = TimeMonitor::getNewCounter ("Timer A");
     RCP<Time> timerB;
     if (myRank == 0) {
       timerB = TimeMonitor::getNewCounter ("Timer B");
     }
     else {
       timerB = null; // True anyway, but I want to make this explicit.
     }
 
     // The actual number of operations in the loop is proportional to
     // the cube of the loop length.  Adjust the quantities below as
     // necessary to ensure the timer reports a nonzero elapsed time
     // for each of the invocations.
     const size_t timerA_loopLength = 150;
     const size_t timerB_loopLength = 200;
 
     // Timer A gets a call count of 3.
     for (size_t k = 0; k < 3; ++k) {
       TimeMonitor monitorA (*timerA);
       slowLoop (timerA_loopLength);
     }
     if (myRank == 0) { // Timer B gets a call count of 1 on Proc 0.
       TimeMonitor monitorB (*timerB);
       slowLoop (timerB_loopLength);
     }
 
     const bool alwaysWriteLocal = false; // the default
     const bool writeGlobalStats = true;  // the default
     const bool writeZeroTimers = true;  // the default
     TimeMonitor::summarize (oss, alwaysWriteLocal, writeGlobalStats,
                             writeZeroTimers, Intersection);
 
     // Echo summarize() output to the FancyOStream out (which is a
     // standard unit test argument).  Output should only appear in
     // show-all-test-details mode.
     out << std::endl << "Testing intersection of timers:" << std::endl
         << oss.str() << std::endl;
 
     // Since setOp == Intersection, only Timer A should be reported,
     // unless there is only one (MPI) process.
     size_t substr_i = oss.str().find ("Timer A");
     TEST_INEQUALITY(substr_i, std::string::npos);
     if (numProcs > 1) {
       substr_i = oss.str().find ("Timer B");
       TEST_EQUALITY(substr_i, std::string::npos);
     }
 
     // Now call summarize(), but ask for a union of timers.
     std::ostringstream ossUnion;
     TimeMonitor::summarize (ossUnion, alwaysWriteLocal, writeGlobalStats,
                             writeZeroTimers, Union);
 
     // Echo summarize() output to the FancyOStream out (which is a
     // standard unit test argument).  Output should only appear in
     // show-all-test-details mode.
     out << std::endl << "Testing union of timers:" << std::endl
         << ossUnion.str() << std::endl;
 
     // Since setOp == Union, both Timer A and Timer B should be
     // reported.
     substr_i = ossUnion.str().find ("Timer A");
     TEST_INEQUALITY(substr_i, std::string::npos);
     substr_i = ossUnion.str().find ("Timer B");
     TEST_INEQUALITY(substr_i, std::string::npos);
 
     // This sets up for the next unit test.
     TimeMonitor::clearCounters ();
   }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [208/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		validateParametersAndSetDefaults
	)

Definition at line 715 of file ParameterList_UnitTests.cpp.

 {
   ParameterList PL_Main = createMainPL();
   ParameterList PL_Main_valid = createValidMainPL();
   ECHO(PL_Main.validateParametersAndSetDefaults(PL_Main_valid));
   TEST_NOTHROW(
     rcp_dynamic_cast<const StringToIntegralParameterEntryValidator<int> >(
       PL_Main.getEntry("Nonlinear Solver").validator(), true ) );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [209/224]

Teuchos::TEUCHOS_UNIT_TEST	(	ParameterList	,
		getIntegralValue_int
	)

Definition at line 726 of file ParameterList_UnitTests.cpp.

 {
   ParameterList PL_Main = createMainPL();
   ParameterList PL_Main_valid = createValidMainPL();
   ECHO(PL_Main.set("Nonlinear Solver", "Line Search Based"));
   ECHO(PL_Main.validateParametersAndSetDefaults(PL_Main_valid));
   ECHO(const int lineSearchValue = getIntegralValue<int>(PL_Main, "Nonlinear Solver"));
   TEST_EQUALITY_CONST(lineSearchValue, 0);
   ECHO(PL_Main.set("Nonlinear Solver", "Trust Region Based"));
   ECHO(const int trustRegionValue  = getIntegralValue<int>(PL_Main, "Nonlinear Solver"));
   TEST_EQUALITY_CONST(trustRegionValue, 1);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [210/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		testDepExceptions
	)

Tests the excpetions associated with Dependencies

Tesint NumberArrayLengthDependency excpetions

Definition at line 745 of file Dependencies_UnitTests.cpp.

                                                           {
     RCP<ParameterList> list1 = RCP<ParameterList>(new ParameterList());
     RCP<ParameterList> list2 = RCP<ParameterList>(new ParameterList());
 
     list1->set("int parameter", 4, "int parameter");
     list1->set("double parameter", 6.0, "double parameter");
     list1->set("string parameter", "hahahaha", "string parameter");
     Array<double> doubleArray(10,23.0);
     list1->set("array parameter", doubleArray, "array parameter");
     list1->set("bool parameter", true, "bool parameter");
 
   RCP<AdditionFunction<int> > intFuncTester = rcp(new
     AdditionFunction<int>(10));
     TEST_THROW(RCP<NumberVisualDependency<int> > numValiDep =
     rcp(
       new NumberVisualDependency<int>(
         list1->getEntryRCP("bool parameter"),
         list1->getEntryRCP("double parameter"),
         true,
         intFuncTester)),
     InvalidDependencyException);
 
     /*
      * Testing StringVisualDepenendcy exceptions.
      */
     RCP<StringVisualDependency> stringVisDep;
     TEST_THROW(stringVisDep = RCP<StringVisualDependency>(
     new StringVisualDependency(
       list1->getEntryRCP("double parameter"),
       list1->getEntryRCP("int parameter"),
       "cheese", true)),
     InvalidDependencyException);
 
     /*
      * Testing BoolVisualDependency exceptions.
      */
     TEST_THROW(RCP<BoolVisualDependency> boolVisDep =
     RCP<BoolVisualDependency>(new BoolVisualDependency(
       list1->getEntryRCP("int parameter"),
       list1->getEntryRCP("double parameter"), false)),
       InvalidDependencyException);
 
   RCP<NumberArrayLengthDependency<int, double> > numArrayLengthDep;
     TEST_THROW(numArrayLengthDep =
       rcp(new NumberArrayLengthDependency<int, double>(
         list1->getEntryRCP("double parameter"),
         list1->getEntryRCP("array parameter"))),
       InvalidDependencyException);
 
     TEST_THROW(numArrayLengthDep =
       rcp(new NumberArrayLengthDependency<int, double>(
         list1->getEntryRCP("int parameter"),
         list1->getEntryRCP("double parameter"))),
       InvalidDependencyException);
 
     /*
      * Testing StringValidatorDependency exceptions.
      */
     RCP<StringToIntegralParameterEntryValidator<int> >
     cheeseValidator = rcp(
         new StringToIntegralParameterEntryValidator<int>(
       tuple<std::string>( "Swiss", "American", "Super Awesome Cheese"),
             "Food Selector"
         )
     );
 
     RCP<StringToIntegralParameterEntryValidator<int> >
     sodaValidator = rcp(
         new StringToIntegralParameterEntryValidator<int>(
             tuple<std::string>( "Pepsi", "Coke", "Kurtis Cola", "Bad Cola" ),
             "Food Selector"
         )
     );
 
     RCP<StringToIntegralParameterEntryValidator<int> >
     chipsValidator = rcp(
         new StringToIntegralParameterEntryValidator<int>(
             tuple<std::string>( "Lays", "Doritos", "Kurtis Super Awesome Brand"),
             "Food Selector"
         )
     );
 
 
     list1->set(
     "string 2 parameter", "Swiss",
     "second string parameter", cheeseValidator);
     StringValidatorDependency::ValueToValidatorMap testValidatorMap1;
     testValidatorMap1["Cheese"] = cheeseValidator;
     testValidatorMap1["Soda"] = sodaValidator;
     testValidatorMap1["Chips"] = chipsValidator;
     TEST_THROW(RCP<StringValidatorDependency> stringValiDep =
     RCP<StringValidatorDependency>(
       new StringValidatorDependency(
         list1->getEntryRCP("int parameter"),
         list1->getEntryRCP("string 2 parameter"),
         testValidatorMap1)),
     InvalidDependencyException);
     RCP<EnhancedNumberValidator<int> > intVali =
     rcp(new EnhancedNumberValidator<int>(0,20));
     testValidatorMap1["Candy"] = intVali;
     TEST_THROW(RCP<StringValidatorDependency> stringValiDep =
     RCP<StringValidatorDependency>(
       new StringValidatorDependency(
         list1->getEntryRCP("string parameter"),
         list1->getEntryRCP("string 2 parameter"),
         testValidatorMap1)),
     InvalidDependencyException);
 
   StringValidatorDependency::ValueToValidatorMap emptyMap;
     TEST_THROW(RCP<StringValidatorDependency> stringValiDep =
     RCP<StringValidatorDependency>(
       new StringValidatorDependency(
         list1->getEntryRCP("string parameter"),
         list1->getEntryRCP("string 2 parameter"),
         emptyMap)),
     InvalidDependencyException);
     
     /*
      * Testing BoolValidatorDependency exceptions.
      */
     RCP<EnhancedNumberValidator<double> > doubleVali1 =
     rcp(new EnhancedNumberValidator<double>(0.0,20.0));
     RCP<EnhancedNumberValidator<double> > doubleVali2 =
     rcp(new EnhancedNumberValidator<double>(5.0,20.0));
     list1->set("double parameter", 6.0, "double parameter", doubleVali1);
 
     TEST_THROW(RCP<BoolValidatorDependency> boolValiDep =
     RCP<BoolValidatorDependency>(
       new BoolValidatorDependency(
         list1->getEntryRCP("int parameter"),
         list1->getEntryRCP("double parameter"),
         doubleVali1,
         doubleVali2)),
     InvalidDependencyException);
 
     TEST_THROW(RCP<BoolValidatorDependency> boolValiDep =
     RCP<BoolValidatorDependency>(
       new BoolValidatorDependency(
       list1->getEntryRCP("bool parameter"),
       list1->getEntryRCP("double parameter"),
       intVali,
       doubleVali2)),
     InvalidDependencyException);
 
     TEST_THROW(RCP<BoolValidatorDependency> boolValiDep =
     RCP<BoolValidatorDependency>(
       new BoolValidatorDependency(
         list1->getEntryRCP("bool parameter"),
         list1->getEntryRCP("double parameter"),
         doubleVali1,
         intVali)),
     InvalidDependencyException);
 
     /*
      * Testing RangeValidatorDependency exceptions.
      */
     list1->set("Cheese to Fondue", "Swiss", "the cheese to fondue");
     RCP<StringToIntegralParameterEntryValidator<int> >
     lowTempCheeseValidator = rcp(
         new StringToIntegralParameterEntryValidator<int>(
             tuple<std::string>( "PepperJack", "Swiss", "American" ),
             "Cheese to Fondue"
         )
     );
     RCP<StringToIntegralParameterEntryValidator<int> >
     highTempCheeseValidator = rcp(
         new StringToIntegralParameterEntryValidator<int>(
             tuple<std::string>("Munster", "Provalone",
         "Kurtis Super Awesome Cheese"),
             "Cheese to Fondue"
         )
     );
 
     list1->set(
     "Cheese to Fondue", "Swiss", "the cheese to fondue",
     lowTempCheeseValidator);
 
     RangeValidatorDependency<double>::RangeToValidatorMap tempranges;
     tempranges[std::pair<double,double>(100,200)] = lowTempCheeseValidator;
     tempranges[std::pair<double,double>(200,300)] = highTempCheeseValidator;
     TEST_THROW(
         RCP<RangeValidatorDependency<double> >
         cheeseTempDep = RCP<RangeValidatorDependency<double> >(
             new RangeValidatorDependency<double>(
               list1->getEntryRCP("string parameter"),
                 list1->getEntryRCP("Cheese to Fondue"),
                 tempranges
             )
         ),
         InvalidDependencyException
     );
 
     tempranges[std::pair<double,double>(400,800)] = intVali;
     TEST_THROW(
         RCP<RangeValidatorDependency<double> >
         cheeseTempDep = RCP<RangeValidatorDependency<double> >(
             new RangeValidatorDependency<double>(
               list1->getEntryRCP("int parameter"),
                 list1->getEntryRCP("Cheese to Fondue"),
                 tempranges
             )
         ),
         InvalidDependencyException
     );
 
   RangeValidatorDependency<double>::RangeToValidatorMap emptyMap2;
     TEST_THROW(
         RCP<RangeValidatorDependency<double> >
         emptyMapDep = RCP<RangeValidatorDependency<double> >(
             new RangeValidatorDependency<double>(
               list1->getEntryRCP("double parameter"),
                 list1->getEntryRCP("Cheese to Fondue"),
                 emptyMap2
             )
         ),
         InvalidDependencyException
     );
 
     RangeValidatorDependency<int>::RangeToValidatorMap badRanges;
     tempranges[std::pair<int,int>(200,100)] = lowTempCheeseValidator;
     TEST_THROW(
         RCP<RangeValidatorDependency<int> >
         cheeseTempDep = RCP<RangeValidatorDependency<int> >(
             new RangeValidatorDependency<int>(
               list1->getEntryRCP("string parameter"),
                 list1->getEntryRCP("Cheese to Fondue"),
                 badRanges
             )
         ),
         InvalidDependencyException
     );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [211/224]

Teuchos::TEUCHOS_UNIT_TEST	(	TimeMonitor	,
		FILTER_ZERO_TIMERS_sameParallelCallCounts
	)

Definition at line 808 of file TimeMonitor_UnitTests.cpp.

   {
     // Store the output of TimeMonitor::summarize() here.
     std::ostringstream oss;
 
     RCP<Time> timerA = TimeMonitor::getNewCounter ("Timer A");
     RCP<Time> timerB = TimeMonitor::getNewCounter ("Timer B");
     RCP<Time> timerC = TimeMonitor::getNewCounter ("Timer C");
 
     // Timers A and B get nonzero elapsed times and call counts on all
     // (MPI) processes.  Timer C never gets started, so it should have
     // a zero elapsed time and zero call count on all processes.
 
     // The actual number of operations in the loop is proportional to
     // the cube of the loop length.  Adjust the quantities below as
     // necessary to ensure the timer reports a nonzero elapsed time
     // for each of the invocations.
     const size_t timerA_loopLength = 200;
     const size_t timerB_loopLength = 250;
 
     // Timer A gets a call count of 3.
     for (size_t k = 0; k < 3; ++k) {
       TimeMonitor monitorA (*timerA);
       slowLoop (size_t (timerA_loopLength));
     }
     // Timer B gets a call count of 1.
     {
       TimeMonitor monitorB (*timerB);
       slowLoop (size_t (timerB_loopLength));
     }
 
     const bool alwaysWriteLocal = false; // the default
     const bool writeGlobalStats = true;  // the default
     const bool writeZeroTimers = false;  // NOT the default
     TimeMonitor::summarize (oss, alwaysWriteLocal, writeGlobalStats,
                             writeZeroTimers);
 
     // Echo summarize() output to the FancyOStream out (which is a
     // standard unit test argument).  Output should only appear in
     // show-all-test-details mode.
     out << oss.str() << std::endl;
 
     // Timers A and B should be reported.
     size_t substr_i = oss.str().find ("Timer A");
     TEST_INEQUALITY(substr_i, std::string::npos);
     substr_i = oss.str().find ("Timer B");
     TEST_INEQUALITY(substr_i, std::string::npos);
 
     // Timer C should NOT be reported.
     substr_i = oss.str().find ("Timer C");
     TEST_EQUALITY(substr_i, std::string::npos);
 
     // This sets up for the next unit test.
     TimeMonitor::clearCounters ();
   }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [212/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		BoolValidatorDepSerialization
	)

Definition at line 818 of file Dependencies_SerializationTests.cpp.

                                                                       {
   std::string dependee1 = "bool param";
   std::string dependee2 = "bool param2";
   std::string dependent1 = "dependent param1";
   std::string dependent2 = "dependent param2";
   ParameterList myDepList("Bool Vali Dep List");
   RCP<DependencySheet> myDepSheet = rcp(new DependencySheet);
   myDepList.set(dependee1, true);
   myDepList.set(dependee2, false);
   myDepList.set(dependent1, 2.0);
   myDepList.set(dependent2, 3.0);
 
     RCP<EnhancedNumberValidator<double> > true1Vali =
     rcp(new EnhancedNumberValidator<double>(0,10));
 
     RCP<EnhancedNumberValidator<double> > false1Vali =
     rcp(new EnhancedNumberValidator<double>(0,30));
 
     RCP<EnhancedNumberValidator<double> > true2Vali =
     rcp(new EnhancedNumberValidator<double>(4,90));
 
 
   RCP<BoolValidatorDependency> simpleBoolValiDep = rcp(
     new BoolValidatorDependency(
       myDepList.getEntryRCP(dependee1),
       myDepList.getEntryRCP(dependent1),
       true1Vali,
       false1Vali));
 
   Dependency::ParameterEntryList dependentList;
   dependentList.insert(myDepList.getEntryRCP(dependent1));
   dependentList.insert(myDepList.getEntryRCP(dependent2));
 
   RCP<BoolValidatorDependency> complexBoolValiDep = rcp(
     new BoolValidatorDependency(
       myDepList.getEntryRCP(dependee2),
       dependentList,
       true2Vali));
 
   myDepSheet->addDependency(simpleBoolValiDep);
   myDepSheet->addDependency(complexBoolValiDep);
 
   RCP<DependencySheet> readInDepSheet = rcp(new DependencySheet);
 
   XMLParameterListWriter plWriter;
   XMLObject xmlOut = plWriter.toXML(myDepList, myDepSheet);
   out << xmlOut.toString();
 
   RCP<ParameterList> readInList =
     writeThenReadPL(myDepList, myDepSheet, readInDepSheet);
 
   RCP<ParameterEntry> readinDependee1 = readInList->getEntryRCP(dependee1);
   RCP<ParameterEntry> readinDependent1 = readInList->getEntryRCP(dependent1);
   RCP<ParameterEntry> readinDependee2 = readInList->getEntryRCP(dependee2);
   RCP<ParameterEntry> readinDependent2 = readInList->getEntryRCP(dependent2);
 
   RCP<Dependency> readinDep1 =
     *(readInDepSheet->getDependenciesForParameter(readinDependee1)->begin());
 
   RCP<Dependency> readinDep2 =
     *(readInDepSheet->getDependenciesForParameter(readinDependee2)->begin());
 
   BASIC_DEPENDENCY_TEST(readinDep1, BoolValidatorDependency, 1, 1);
   VERIFY_DEPENDEE(readinDep1, readinDependee1);
   VERIFY_DEPENDENT(readinDep1, readinDependent1);
 
   BASIC_DEPENDENCY_TEST(readinDep2, BoolValidatorDependency, 1, 2);
   VERIFY_DEPENDEE(readinDep2, readinDependee2);
   VERIFY_DEPENDENT(readinDep2, readinDependent1);
   VERIFY_DEPENDENT(readinDep2, readinDependent2);
 
 
   RCP<BoolValidatorDependency> castedDep1 =
     rcp_dynamic_cast<BoolValidatorDependency>(readinDep1, true);
   RCP<BoolValidatorDependency> castedDep2 =
     rcp_dynamic_cast<BoolValidatorDependency>(readinDep2, true);
 
   TEST_ASSERT(nonnull(castedDep1->getTrueValidator()));
   TEST_ASSERT(nonnull(castedDep1->getFalseValidator()));
   TEST_ASSERT(nonnull(castedDep2->getTrueValidator()));
   TEST_ASSERT(castedDep2->getFalseValidator().is_null());
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator<double> >(
       castedDep1->getTrueValidator(), true)->getMax(),
     true1Vali->getMax());
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator<double> >(
       castedDep1->getFalseValidator(), true)->getMax(),
     false1Vali->getMax());
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator<double> >(
       castedDep2->getTrueValidator(), true)->getMax(),
     true2Vali->getMax());
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [213/224]

Teuchos::TEUCHOS_UNIT_TEST	(	TimeMonitor	,
		FILTER_ZERO_TIMERS_differentParallelCallCounts
	)

Definition at line 869 of file TimeMonitor_UnitTests.cpp.

   {
     RCP<const Comm<int> > comm = Teuchos::DefaultComm<int>::getComm ();
     const int myRank = comm->getRank ();
 
     // If MPI has not been initialized, turn the MPI communicator into
     // a "serial" communicator.  This may not be necessary when using
     // the Teuchos Unit Test Framework.
 #ifdef HAVE_MPI
     {
       int mpiHasBeenInitialized = 0;
       MPI_Initialized (&mpiHasBeenInitialized);
       if (! mpiHasBeenInitialized) {
         comm = Teuchos::DefaultComm<int>::getDefaultSerialComm (null);
       }
     }
 #endif // HAVE_MPI
 
     // Store the output of TimeMonitor::summarize() here.
     std::ostringstream oss;
 
     RCP<Time> timerA = TimeMonitor::getNewCounter ("Timer A");
     RCP<Time> timerB = TimeMonitor::getNewCounter ("Timer B");
     RCP<Time> timerC = TimeMonitor::getNewCounter ("Timer C");
 
     // Timer A gets a nonzero elapsed time and call count on Proc 0,
     // but a zero elapsed time and call count elsewhere.
     //
     // Timer B gets the same nonzero elapsed time and call count on
     // all MPI procs.
     //
     // Timer C gets a zero elapsed time and call count on all procs.
     //
     // The actual number of operations in the loop is proportional to
     // the cube of the loop length.  Adjust the quantities below as
     // necessary to ensure the timer reports a nonzero elapsed time
     // for each of the invocations.
     const size_t timerA_loopLength = 200;
     const size_t timerB_loopLength = 500;
 
     if (myRank == 0) {
       // Timer A gets a call count of 3 on Proc 0.
       for (int k = 0; k < 3; ++k) {
         TimeMonitor monitorA (*timerA);
         slowLoop (size_t (timerA_loopLength));
       }
     }
 
     // Timer B gets a call count of 1 on all procs.
     {
       TimeMonitor monitorB (*timerB);
       slowLoop (size_t (timerB_loopLength));
     }
 
     const bool alwaysWriteLocal = false; // the default
     const bool writeGlobalStats = true;  // the default
     const bool writeZeroTimers = false;  // NOT the default
     TimeMonitor::summarize (oss, alwaysWriteLocal, writeGlobalStats,
                             writeZeroTimers, Union);
 
     // Echo summarize() output to the FancyOStream out (which is a
     // standard unit test argument).  Output should only appear in
     // show-all-test-details mode.
     out << oss.str() << std::endl;
 
     // Timers A and B should both be reported.
     size_t substr_i = oss.str().find ("Timer A");
     TEST_INEQUALITY(substr_i, std::string::npos);
     substr_i = oss.str().find ("Timer B");
     TEST_INEQUALITY(substr_i, std::string::npos);
 
     // Timer C should NOT be reported.
     substr_i = oss.str().find ("Timer C");
     TEST_EQUALITY(substr_i, std::string::npos);
 
     // This sets up for the next unit test (if there is one).
     TimeMonitor::clearCounters ();
   }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [214/224]

Teuchos::TEUCHOS_UNIT_TEST	(	TimeMonitor	,
		IgnoreMissingTimers
	)

Definition at line 951 of file TimeMonitor_UnitTests.cpp.

   {
     RCP<const Comm<int> > comm = Teuchos::DefaultComm<int>::getComm ();
     const int myRank = comm->getRank ();
 
 #ifdef HAVE_MPI
     {
       int mpiHasBeenInitialized = 0;
       MPI_Initialized (&mpiHasBeenInitialized);
       if (! mpiHasBeenInitialized) {
         comm = Teuchos::DefaultComm<int>::getDefaultSerialComm (null);
       }
     }
 #endif // HAVE_MPI
 
     // Store the output of TimeMonitor::summarize() here.
     std::ostringstream oss;
 
     std::string timerName="Timer Z";
     // Timer Z appears on all PIDs except 0.
     {
       switch (myRank) {
         case 1 :
           break;
         case 0 :
           {
           RCP<Time> timer = TimeMonitor::getNewCounter (timerName);
           TimeMonitor monitor (*timer);
           sleep(1);
           }
           break;
         case 2 :
           {
           RCP<Time> timer = TimeMonitor::getNewCounter (timerName);
           TimeMonitor monitor (*timer);
           sleep(1);
           }
           break;
         default :
           {
           RCP<Time> timer = TimeMonitor::getNewCounter (timerName);
           TimeMonitor monitor (*timer);
           sleep(1);
           }
     }
     }
 
     // test two versions of summarize with default behavior
 
     //version 1, comm provided
     const bool alwaysWriteLocal = false;
     const bool writeGlobalStats = true;
     const bool writeZeroTimers = false;
     bool ignoreMissingTimers = false;        // the default
     std::string filter = "";
     TimeMonitor::summarize (comm.ptr(), oss, alwaysWriteLocal, writeGlobalStats,
                             writeZeroTimers, Union, filter, ignoreMissingTimers);
 
     // Echo summarize() output to the FancyOStream out (which is a
     // standard unit test argument).  Output should only appear in
     // show-all-test-details mode.
     out << oss.str() << std::endl;
 
     if (comm->getSize() > 1) {
       // The min should be 0
       size_t substr_i = oss.str().find ("0 (0)");
       TEST_INEQUALITY(substr_i, std::string::npos);
     }
 
     //version 2, no comm provided
     std::ostringstream oss2;
     TimeMonitor::summarize (oss2, alwaysWriteLocal, writeGlobalStats,
                             writeZeroTimers, Union, filter, ignoreMissingTimers);
     out << oss2.str() << std::endl;
     if (comm->getSize() > 1) {
       // The min should be 0
       size_t substr_i = oss2.str().find ("0 (0)");
       TEST_INEQUALITY(substr_i, std::string::npos);
     }
 
     // test two versions of summarize with *non* default behavior
     //version 1, comm provided
     ignoreMissingTimers = true;              // NOT the default
     std::ostringstream oss3;
     TimeMonitor::summarize (comm.ptr(), oss3, alwaysWriteLocal, writeGlobalStats,
                             writeZeroTimers, Union, filter, ignoreMissingTimers);
     out << oss3.str() << std::endl;
 
     // The min should be different from 0
     size_t substr_i = oss3.str().find ("0 (0)");
     TEST_EQUALITY(substr_i, std::string::npos);
 
     //version 2, no comm provided
     std::ostringstream oss4;
     TimeMonitor::summarize (oss4, alwaysWriteLocal, writeGlobalStats,
                             writeZeroTimers, Union, filter, ignoreMissingTimers);
     out << oss4.str() << std::endl;
     // The min should be different from 0
     substr_i = oss4.str().find ("0 (0)");
     TEST_EQUALITY(substr_i, std::string::npos);
 
     // This sets up for the next unit test (if there is one).
     TimeMonitor::clearCounters ();
   }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [215/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		DepSheetTest
	)

Tests various DependencySheet functions.

Definition at line 983 of file Dependencies_UnitTests.cpp.

                                                      {
     RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
   RCP<BoolVisualDependency> boolDep1 =
     DummyObjectGetter<BoolVisualDependency>::getDummyObject();
   TEST_ASSERT(depSheet1->empty());
   depSheet1->addDependency(boolDep1);
   TEST_ASSERT(!depSheet1->empty());
 
 
   RCP<DependencySheet> depSheet2 = rcp(new DependencySheet);
   RCP<StringVisualDependency> stringDep1 =
     DummyObjectGetter<StringVisualDependency>::getDummyObject();
   depSheet1->addDependency(stringDep1);
   RCP<StringValidatorDependency> stringValiDep1 =
     DummyObjectGetter<StringValidatorDependency>::getDummyObject();
   depSheet1->addDependency(stringValiDep1);
 
   depSheet1->addDependencies(depSheet2);
   TEST_EQUALITY_CONST(depSheet1->size(), 3);
   bool found1 = false;
   bool found2 = false;
   bool found3 = false;
   for(
     DependencySheet::DepSet::iterator it = depSheet1->depBegin();
     it != depSheet1->depEnd();
     ++it
   )
   {
     if(*it == boolDep1){
       found1 = true;
     }
     else if(*it == stringDep1){
       found2 = true;
     }
     else if(*it == stringValiDep1){
       found3 = true;
     }
   }
   TEST_ASSERT(found1);
   TEST_ASSERT(found2);
   TEST_ASSERT(found3);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [216/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		NumberVisualDepSerializationExceptions
	)

Definition at line 1103 of file Dependencies_SerializationTests.cpp.

                                                                                {
 
   EXCEPTION_TEST_BOILERPLATE(4, "blah");
   RCP<Dependency> numVisDep =
     rcp(new NumberVisualDependency<int>(dependeeParam1, dependentParam1));
   CONVERT_DEP_TO_XML(numVisDep);
   TOO_MANY_DEPENDEE_TEST(numVisDep);
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [217/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		BoolVisualDepSerializationExceptions
	)

Definition at line 1113 of file Dependencies_SerializationTests.cpp.

                                                                              {
   EXCEPTION_TEST_BOILERPLATE(true, "blah");
   RCP<Dependency> boolVisDep =
     rcp(new BoolVisualDependency(dependeeParam1, dependentParam1));
   CONVERT_DEP_TO_XML(boolVisDep);
   TOO_MANY_DEPENDEE_TEST(boolVisDep);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [218/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		StringVisualDepSerializationExceptions
	)

Definition at line 1121 of file Dependencies_SerializationTests.cpp.

 {
   EXCEPTION_TEST_BOILERPLATE(std::string("balh"), 4);
   RCP<Dependency> stringVisDep =
     rcp(new StringVisualDependency(dependeeParam1, dependentParam1, "steve"));
   CONVERT_DEP_TO_XML(stringVisDep);
   TOO_MANY_DEPENDEE_TEST(stringVisDep);
 
   COPY_DEPTAG_WITHOUT_CHILD(
     stringVisDepXML,
     StringVisualDependencyXMLConverter::getStringValuesTagName(),
     missingValuesXML);
 
   TEST_THROW(
     DependencyXMLConverterDB::convertXML(
       missingValuesXML, readerEntryMap, readerValiMap),
     ValuesTagMissingException);
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [219/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		ConditionVisualDepSerializationExceptions
	)

Definition at line 1141 of file Dependencies_SerializationTests.cpp.

 {
   EXCEPTION_TEST_BOILERPLATE(true, 4);
   RCP<Condition> boolCon = rcp(new BoolCondition(dependeeParam1));
   RCP<Dependency> conVisDep =
     rcp(new ConditionVisualDependency(boolCon, dependentParam1));
   CONVERT_DEP_TO_XML(conVisDep);
   COPY_DEPTAG_WITHOUT_CHILD(
     conVisDepXML,
     Condition::getXMLTagName(),
     missingConXML);
 
   TEST_THROW(
     DependencyXMLConverterDB::convertXML(
       missingConXML, readerEntryMap, readerValiMap),
     MissingConditionTagException);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [220/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		BoolValidatorDepSerializationExceptions
	)

Definition at line 1160 of file Dependencies_SerializationTests.cpp.

 {
   EXCEPTION_TEST_BOILERPLATE(true, 7);
   RCP<EnhancedNumberValidator<int> > trueVali =
     rcp(new EnhancedNumberValidator<int>);
   RCP<EnhancedNumberValidator<int> > falseVali =
     rcp(new EnhancedNumberValidator<int>);
   INSERT_VALIDATOR_TO_MAPS(trueVali);
   INSERT_VALIDATOR_TO_MAPS(falseVali);
   RCP<Dependency> boolValiDep =
     rcp(new BoolValidatorDependency(
       dependeeParam1,
       dependentParam1,
       trueVali,
       falseVali));
   CONVERT_DEP_TO_XML(boolValiDep);
   TOO_MANY_DEPENDEE_TEST(boolValiDep);
 
   readerValiMap.erase(writerValiMap.find(trueVali)->second);
 
   TEST_THROW(
     DependencyXMLConverterDB::convertXML(
       boolValiDepXML, readerEntryMap, readerValiMap),
     MissingValidatorException);
 
   readerValiMap.insert( IDtoValidatorMap::IDValidatorPair(
       writerValiMap.find(trueVali)->second, trueVali));
   readerValiMap.erase(writerValiMap.find(falseVali)->second);
 
   TEST_THROW(
     DependencyXMLConverterDB::convertXML(
       boolValiDepXML, readerEntryMap, readerValiMap),
     MissingValidatorException);
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [221/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		StringValidatorDepSerializationExceptions
	)

Definition at line 1197 of file Dependencies_SerializationTests.cpp.

 {
   EXCEPTION_TEST_BOILERPLATE(std::string("blah"), 4);
   RCP<FileNameValidator> scrapVali =
     DummyObjectGetter<FileNameValidator>::getDummyObject();
   RCP<FileNameValidator> scrapVali2 =
     DummyObjectGetter<FileNameValidator>::getDummyObject();
   StringValidatorDependency::ValueToValidatorMap valiMap;
   valiMap["blah"] = scrapVali;
   INSERT_VALIDATOR_TO_MAPS(scrapVali);
   INSERT_VALIDATOR_TO_MAPS(scrapVali2);
 
   RCP<Dependency> stringValiDep =
     rcp( new StringValidatorDependency(
       dependeeParam1, dependentParam1, valiMap, scrapVali2));
   CONVERT_DEP_TO_XML(stringValiDep);
 
   TOO_MANY_DEPENDEE_TEST(stringValiDep);
 
   COPY_DEPTAG_WITHOUT_CHILD(
     stringValiDepXML,
     StringValidatorDependencyXMLConverter::getValuesAndValidatorsTag(),
     missingValuesXML);
 
   TEST_THROW(
     DependencyXMLConverterDB::convertXML(
       missingValuesXML, readerEntryMap, readerValiMap),
     MissingValuesAndValidatorsTagException);
 
   readerValiMap.erase(writerValiMap.find(scrapVali)->second);
 
   TEST_THROW(
     DependencyXMLConverterDB::convertXML(
       stringValiDepXML, readerEntryMap, readerValiMap),
     MissingValidatorException);
 
   readerValiMap.insert( IDtoValidatorMap::IDValidatorPair(
       writerValiMap.find(scrapVali)->second,scrapVali));
   readerValiMap.erase(writerValiMap.find(scrapVali2)->second);
 
   TEST_THROW(
     DependencyXMLConverterDB::convertXML(
       stringValiDepXML, readerEntryMap, readerValiMap),
     MissingValidatorException);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [222/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		RangeValidatorDepSerializationExceptions
	)

Definition at line 1244 of file Dependencies_SerializationTests.cpp.

 {
   EXCEPTION_TEST_BOILERPLATE(3, "blah");
 
   RCP<FileNameValidator> scrapVali =
     DummyObjectGetter<FileNameValidator>::getDummyObject();
   RCP<FileNameValidator> otherScrapVali =
     DummyObjectGetter<FileNameValidator>::getDummyObject();
   RCP<FileNameValidator> defaultScrapVali =
     DummyObjectGetter<FileNameValidator>::getDummyObject();
   RangeValidatorDependency<int>::RangeToValidatorMap valiMap;
   RangeValidatorDependency<int>::RangeToValidatorMap secondvaliMap;
   RangeValidatorDependency<int>::Range scrapRange(2,5);
   valiMap[scrapRange] = scrapVali;
   secondvaliMap[scrapRange] = otherScrapVali;
   writerValiMap.insert(scrapVali);
   writerValiMap.insert(otherScrapVali);
   writerValiMap.insert(defaultScrapVali);
   readerValiMap.insert(
     IDtoValidatorMap::IDValidatorPair(
       writerValiMap.find(scrapVali)->second,scrapVali));
   readerValiMap.insert(
     IDtoValidatorMap::IDValidatorPair(
       writerValiMap.find(otherScrapVali)->second,otherScrapVali));
   readerValiMap.insert(
     IDtoValidatorMap::IDValidatorPair(
       writerValiMap.find(defaultScrapVali)->second,defaultScrapVali));
 
   RCP<Dependency> rangeDep =
    rcp(new RangeValidatorDependency<int>(
     dependeeParam1, dependentParam1, valiMap));
 
   RCP<Dependency> rangeDefaultDep =
    rcp(new RangeValidatorDependency<int>(
     dependeeParam1, dependentParam1, secondvaliMap, defaultScrapVali));
 
   CONVERT_DEP_TO_XML(rangeDep);
   CONVERT_DEP_TO_XML(rangeDefaultDep);
 
   TOO_MANY_DEPENDEE_TEST(rangeDep);
 
   COPY_DEPTAG_WITHOUT_CHILD(
     rangeDepXML,
     RangeValidatorDependencyXMLConverter<int>::getRangesAndValidatorsTag(),
     missingRangesXML
   )
 
   TEST_THROW(
     DependencyXMLConverterDB::convertXML(
       missingRangesXML, readerEntryMap, readerValiMap),
     MissingRangesAndValidatorsTagException);
 
   readerValiMap.erase(writerValiMap.find(scrapVali)->second);
 
   TEST_THROW(
     DependencyXMLConverterDB::convertXML(
      rangeDepXML, readerEntryMap, readerValiMap),
     MissingValidatorException);
 
   readerValiMap.erase(writerValiMap.find(defaultScrapVali)->second);
   TEST_THROW(
     DependencyXMLConverterDB::convertXML(
      rangeDefaultDepXML, readerEntryMap, readerValiMap),
     MissingValidatorException);
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [223/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		NumArrayLengthDepSerializationExceptions
	)

Definition at line 1312 of file Dependencies_SerializationTests.cpp.

 {
   EXCEPTION_TEST_BOILERPLATE(4, Array<double>(4, 3.0));
   RCP<Dependency> numArrayLengthDep =
     rcp(new NumberArrayLengthDependency<int, double>(
       dependeeParam1, dependentParam1));
   CONVERT_DEP_TO_XML(numArrayLengthDep);
   TOO_MANY_DEPENDEE_TEST(numArrayLengthDep);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST() [224/224]

Teuchos::TEUCHOS_UNIT_TEST	(	Teuchos_Dependencies	,
		DepSheetTests
	)

Specific DependencySheet tests

Definition at line 1324 of file Dependencies_SerializationTests.cpp.

 {
   ParameterList myDepList("String Visual Dep List");
   std::string dependee1 = "dependee1";
   std::string dependent1 = "dependent1";
   RCP<DependencySheet> myDepSheet = rcp(new DependencySheet("My List"));
   myDepList.set(dependee1, "val1");
   myDepList.set(dependent1, 2.0);
   StringVisualDependency::ValueList valList1 = tuple<std::string>("val1");
   RCP<StringVisualDependency> basicStringVisDep = rcp(
     new StringVisualDependency(
       myDepList.getEntryRCP(dependee1),
       myDepList.getEntryRCP(dependent1),
       valList1));
   myDepSheet->addDependency(basicStringVisDep);
 
   RCP<DependencySheet> readInDepSheet = rcp(new DependencySheet);
 
   XMLParameterListWriter plWriter;
   XMLObject xmlOut = plWriter.toXML(myDepList, myDepSheet);
   out << xmlOut.toString();
 
   RCP<ParameterList> readInList =
     writeThenReadPL(myDepList, myDepSheet, readInDepSheet);
   TEST_EQUALITY(readInDepSheet->getName(), myDepSheet->getName());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [1/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	Teuchos_Conditions	,
		NumberConditionSerialization	,
		T
	)

Definition at line 173 of file Condition_Serialization_UnitTests.cpp.

                                                                                       {
   ConditionXMLConverterDB::printKnownConverters(out);
   std::string paramName1 = "T param";
   std::string paramName2 = "T param 2";
   std::string dependent1Name = "dependent1";
   std::string dependent2Name = "dependent2";
   T paramValue = ScalarTraits< T >::one();
   T ten = 10 * ScalarTraits< T >::one();
   std::string dependentValue = "hi there!";
   ParameterList testList("Condition Test List");
   testList.set(paramName1, paramValue);
   testList.set(paramName2, paramValue);
   testList.set(dependent1Name, dependentValue);
   testList.set(dependent2Name, dependentValue);
 
   RCP<NumberCondition< T > > numberCon =
     rcp(new NumberCondition< T >(testList.getEntryRCP(paramName1)));
 
   RCP<SubtractionFunction< T > > funcTester =
     rcp(new SubtractionFunction< T >(ten));
 
   RCP<NumberCondition< T > > numberFuncCon =
     rcp(new NumberCondition< T >(testList.getEntryRCP(paramName2), funcTester));
 
   RCP<ConditionVisualDependency> numberConDep =
     rcp(new ConditionVisualDependency(
       numberCon,
       testList.getEntryRCP(dependent1Name)));
 
   RCP<ConditionVisualDependency> funcNumberConDep =
     rcp(new ConditionVisualDependency(
       numberFuncCon,
       testList.getEntryRCP(dependent2Name)));
 
   RCP<DependencySheet> depSheet1 = rcp(new DependencySheet);
   depSheet1->addDependency(numberConDep);
   depSheet1->addDependency(funcNumberConDep);
 
   RCP<DependencySheet> depSheetIn = rcp(new DependencySheet);
   RCP<ParameterList> readinList =
     writeThenReadPL(testList, depSheet1, depSheetIn);
 
   RCP<ParameterEntry> readInDependee1 = readinList->getEntryRCP(paramName1);
   RCP<ParameterEntry> readInDependee2 = readinList->getEntryRCP(paramName2);
 
 
 
 
   RCP<ConditionVisualDependency> simpleReadInDep =
     rcp_dynamic_cast<ConditionVisualDependency>(
       *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()));
   TEST_EQUALITY(
     simpleReadInDep->getCondition()->getTypeAttributeValue(),
     DummyObjectGetter<NumberCondition< T > >::getDummyObject()->getTypeAttributeValue());
   RCP<const NumberCondition< T > > simpleReadInCon =
     rcp_dynamic_cast<const NumberCondition< T > >(simpleReadInDep->getCondition(), true);
   TEST_ASSERT(nonnull(simpleReadInCon));
 
 
   RCP<ConditionVisualDependency> funcReadInDep =
     rcp_dynamic_cast<ConditionVisualDependency>(
       *(depSheetIn->getDependenciesForParameter(readInDependee2)->begin()));
   TEST_ASSERT(funcReadInDep != null);
 
   RCP<const NumberCondition< T > > funcReadInCon =
     rcp_dynamic_cast<const NumberCondition< T > >(funcReadInDep->getCondition());
 
   TEST_ASSERT(funcReadInCon != null);
 
   RCP<const SubtractionFunction< T > > funcReadInFunc =
     rcp_dynamic_cast<const SubtractionFunction< T > >(
       funcReadInCon->getFunctionObject());
   TEST_ASSERT(funcReadInFunc != null);
   TEST_EQUALITY(
     funcReadInFunc->getModifiyingOperand(),
     funcTester->getModifiyingOperand());
 
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [2/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	Teuchos_Validator	,
		EnhancedNumberValidatorConverter	,
		T
	)

Definition at line 254 of file Validator_SerializationTest.cpp.

 {
   std::string xmlFileName = TypeNameTraits<T>::name() + "EnhancedValidatorList.xml";
   std::string defaultParameterName = "default";
   std::string minmaxParameterName = "min max";
   std::string stepPrecParameterName = "step and prec";
   ParameterList myList;
   RCP<EnhancedNumberValidator< T > > defaultValidator =
     rcp( new EnhancedNumberValidator< T >());
   RCP<EnhancedNumberValidator< T > > minMaxValidator =
     rcp( new EnhancedNumberValidator< T >(0,10));
   RCP<EnhancedNumberValidator< T > > stepAndPrecValidator =
     rcp( new EnhancedNumberValidator< T >(0,10,4,4));
   myList.set(defaultParameterName, ( T )6, "parameter with default validator",
     defaultValidator);
   myList.set(minmaxParameterName, ( T )10, "parameter with min and max validator",
     minMaxValidator);
   myList.set(stepPrecParameterName, ( T )10, "parameter with min, max, "
     "step, and prec validator",
     stepAndPrecValidator);
 
   RCP<ParameterList> readInPL = writeThenReadPL(myList);
 
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(defaultParameterName).validator(), true)->getMin(),
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(defaultParameterName).validator(), true)->getMin()
   );
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(defaultParameterName).validator(), true)->getMax(),
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(defaultParameterName).validator(), true)->getMax()
   );
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(defaultParameterName).validator(), true)->getStep()
     ,
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(defaultParameterName).validator(), true)->getStep()
   );
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(
         defaultParameterName).validator(), true)->getPrecision(),
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(
         defaultParameterName).validator(), true)->getPrecision()
   );
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(defaultParameterName).validator(), true)->hasMin(),
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(defaultParameterName).validator(), true)->hasMin()
   );
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(defaultParameterName).validator(), true)->hasMax(),
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(defaultParameterName).validator(), true)->hasMax()
   );
 
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(minmaxParameterName).validator(), true)->getMin(),
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(minmaxParameterName).validator(), true)->getMin()
   );
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(minmaxParameterName).validator(), true)->getMax(),
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(minmaxParameterName).validator(), true)->getMax()
   );
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(minmaxParameterName).validator(), true)->getStep(),
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(minmaxParameterName).validator(), true)->getStep()
   );
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(
         minmaxParameterName).validator(), true)->getPrecision(),
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(
         minmaxParameterName).validator(), true)->getPrecision()
   );
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(minmaxParameterName).validator(), true)->hasMin(),
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(minmaxParameterName).validator(), true)->hasMin()
   );
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(minmaxParameterName).validator(), true)->hasMax(),
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(minmaxParameterName).validator(), true)->hasMax()
   );
 
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(stepPrecParameterName).validator(), true)->getMin(),
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(stepPrecParameterName).validator(), true)->getMin()
   );
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(stepPrecParameterName).validator(), true)->getMax(),
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(stepPrecParameterName).validator(), true)->getMax()
   );
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(stepPrecParameterName).validator(), true)->getStep()
     ,
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(stepPrecParameterName).validator(), true)->getStep()
   );
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       readInPL->getEntry(
         stepPrecParameterName).validator(), true)->getPrecision(),
     rcp_dynamic_cast<const EnhancedNumberValidator< T > >(
       myList.getEntry(
         stepPrecParameterName).validator(), true)->getPrecision());
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [3/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	RCPNodeHandle	,
		basicConstruct_owns_mem	,
		T
	)

Definition at line 323 of file RCPNodeHandle_UnitTests.cpp.

 {
   T *p = 0;
   RCPNodeHandle nodeRef(basicRCPNodeHandle<T>(true, &p));
   TEST_EQUALITY_CONST( nodeRef.count(), 1 );
   TEST_EQUALITY_CONST( nodeRef.has_ownership(), true );
   nodeRef.has_ownership(false);
   TEST_EQUALITY_CONST( nodeRef.has_ownership(), false );
 #ifdef TEUCHOS_DEBUG
   TEST_INEQUALITY_CONST( nodeRef.get_base_obj_map_key_void_ptr(), static_cast<void*>(0) );
   TEST_EQUALITY( nodeRef.get_base_obj_map_key_void_ptr(), static_cast<void*>(p) );
   TEST_THROW({any &a = nodeRef.get_extra_data("int","blob"); (void)a;},
     std::invalid_argument);
   TEST_THROW({const any &a = getConst(nodeRef).get_extra_data("int","blob"); (void)a;},
     std::invalid_argument);
 #endif // TEUCHOS_DEBUG
   TEST_EQUALITY_CONST(nodeRef.get_optional_extra_data("int","blob"), 0);
   TEST_EQUALITY_CONST(getConst(nodeRef).get_optional_extra_data("int","blob"), 0);
   nodeRef.has_ownership(true);
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [4/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	Teuchos_Dependencies	,
		NumberVisualDepSerialization	,
		T
	)

Definition at line 328 of file Dependencies_SerializationTests.cpp.

 {
   std::string dependee1 = "num param";
   std::string dependee2 = "num param2";
   std::string dependent1 = "dependent param1";
   std::string dependent2 = "dependent param2";
   ParameterList myDepList("Number Visual Dep List");
   RCP<DependencySheet> myDepSheet = rcp(new DependencySheet);
   myDepList.set(dependee1, ScalarTraits<T>::one());
   myDepList.set(dependee2, ScalarTraits<T>::one());
   myDepList.set(dependent1, true);
   myDepList.set(dependent2, "vale");
 
   RCP<NumberVisualDependency<T> > simpleNumVisDep = rcp(
     new NumberVisualDependency<T>(
       myDepList.getEntryRCP(dependee1),
       myDepList.getEntryRCP(dependent1)));
 
   Dependency::ParameterEntryList dependentList;
   dependentList.insert(myDepList.getEntryRCP(dependent1));
   dependentList.insert(myDepList.getEntryRCP(dependent2));
 
   T ten = ScalarTraits<T>::one() *10;
   RCP<SubtractionFunction<T> > subFunction = rcp(new SubtractionFunction<T>(ten));
   RCP<NumberVisualDependency<T> > complexNumVisDep = rcp(
     new NumberVisualDependency<T>(
       myDepList.getEntryRCP(dependee2),
       dependentList,
       true,
       subFunction));
 
   myDepSheet->addDependency(simpleNumVisDep);
   myDepSheet->addDependency(complexNumVisDep);
 
   RCP<DependencySheet> readInDepSheet = rcp(new DependencySheet);
 
   XMLParameterListWriter plWriter;
   XMLObject xmlOut = plWriter.toXML(myDepList, myDepSheet);
   out << xmlOut.toString();
 
   RCP<ParameterList> readInList =
     writeThenReadPL(myDepList, myDepSheet, readInDepSheet);
 
   RCP<ParameterEntry> readinDependee1 = readInList->getEntryRCP(dependee1);
   RCP<ParameterEntry> readinDependent1 = readInList->getEntryRCP(dependent1);
   RCP<ParameterEntry> readinDependee2 = readInList->getEntryRCP(dependee2);
   RCP<ParameterEntry> readinDependent2 = readInList->getEntryRCP(dependent2);
 
   RCP<Dependency> readinDep1 =
     *(readInDepSheet->getDependenciesForParameter(readinDependee1)->begin());
 
   RCP<Dependency> readinDep2 =
     *(readInDepSheet->getDependenciesForParameter(readinDependee2)->begin());
 
   BASIC_DEPENDENCY_TEST(readinDep1, NumberVisualDependency<T>, 1, 1);
   VERIFY_DEPENDEE(readinDep1, readinDependee1);
   VERIFY_DEPENDENT(readinDep1, readinDependent1);
 
   BASIC_DEPENDENCY_TEST(readinDep2, NumberVisualDependency<T>, 1, 2);
   VERIFY_DEPENDEE(readinDep2, readinDependee2);
   VERIFY_DEPENDENT(readinDep2, readinDependent1);
   VERIFY_DEPENDENT(readinDep2, readinDependent2);
 
 
   RCP<NumberVisualDependency<T> > castedDep1 =
     rcp_dynamic_cast<NumberVisualDependency<T> >(readinDep1, true);
   RCP<NumberVisualDependency<T> > castedDep2 =
     rcp_dynamic_cast<NumberVisualDependency<T> >(readinDep2, true);
 
   TEST_EQUALITY(castedDep1->getShowIf(), simpleNumVisDep->getShowIf());
   TEST_EQUALITY(castedDep2->getShowIf(), complexNumVisDep->getShowIf());
 
   RCP<const SimpleFunctionObject<T> > functionObject =
     castedDep2->getFunctionObject();
   TEST_ASSERT(functionObject != null);
   RCP<const SubtractionFunction<T> > castedFunction =
     rcp_dynamic_cast<const SubtractionFunction<T> >(functionObject);
   TEST_ASSERT(castedFunction != null);
   TEST_EQUALITY(
     castedFunction->getModifiyingOperand(),
     subFunction->getModifiyingOperand());
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [5/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	RCPNodeHandle	,
		basicConstruct_no_owns_mem	,
		T
	)

Definition at line 345 of file RCPNodeHandle_UnitTests.cpp.

 {
   RCPNodeHandle nodeRef(basicRCPNodeHandle<T>(false));
   TEST_EQUALITY_CONST( nodeRef.count(), 1 );
   TEST_EQUALITY_CONST( nodeRef.has_ownership(), false );
   nodeRef.has_ownership(true);
   TEST_EQUALITY_CONST( nodeRef.has_ownership(), true );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [6/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	RCPNodeHandle	,
		weakPtr_basic_1	,
		T
	)

Definition at line 355 of file RCPNodeHandle_UnitTests.cpp.

 {
 
   ECHO(RCPNodeHandle nodeRef1(basicRCPNodeHandle<T>(true)));
   TEST_EQUALITY_CONST( nodeRef1.strength(), RCP_STRONG );
 
   ECHO(RCPNodeHandle nodeRef2 = nodeRef1.create_weak());
 
   TEST_EQUALITY_CONST( nodeRef2.strength(), RCP_WEAK );
   TEST_EQUALITY_CONST( nodeRef1.strong_count(), 1 );
   TEST_EQUALITY_CONST( nodeRef1.weak_count(), 1 );
   TEST_EQUALITY_CONST( nodeRef2.strong_count(), 1 );
   TEST_EQUALITY_CONST( nodeRef2.weak_count(), 1 );
 
   ECHO(RCPNodeHandle nodeRef3 = nodeRef2.create_strong());
 
   TEST_EQUALITY_CONST( nodeRef3.strength(), RCP_STRONG );
   TEST_EQUALITY_CONST( nodeRef1.strong_count(), 2 );
   TEST_EQUALITY_CONST( nodeRef1.weak_count(), 1 );
   TEST_EQUALITY_CONST( nodeRef2.strong_count(), 2 );
   TEST_EQUALITY_CONST( nodeRef2.weak_count(), 1 );
 
   MockRCP<T> mockRCP;
   ECHO(nodeRef2.debug_assert_valid_ptr(mockRCP)); // Should not throw!
 
   // This will make the underlying object T get deleted!
   ECHO(nodeRef1 = null);
   ECHO(nodeRef3 = null);
 
   TEST_EQUALITY_CONST( nodeRef1.node_ptr()==0, true );
   TEST_EQUALITY_CONST( nodeRef1.is_node_null(), true );
   TEST_EQUALITY_CONST( nodeRef1.is_valid_ptr(), true );
 
   TEST_EQUALITY_CONST( nodeRef2.node_ptr()!=0, true );
   TEST_EQUALITY_CONST( nodeRef2.is_node_null(), false );
   TEST_EQUALITY_CONST( nodeRef2.is_valid_ptr(), false );
 
 #ifdef TEUCHOS_DEBUG
   TEST_THROW( nodeRef2.debug_assert_valid_ptr(mockRCP),
     DanglingReferenceError );
 #endif
 
   ECHO(nodeRef2 = null); // Should make the underlying node go away
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [7/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	Teuchos_Validator	,
		NumberArrayValidatorConverterTest	,
		T
	)

Definition at line 386 of file Validator_SerializationTest.cpp.

 {
   std::string arrayParameterName = "array";
   ParameterList myList;
 
   const T arrayValidatorLen = as<T>(11);
   RCP<ArrayNumberValidator< T > > arrayValidator =
     rcp(new ArrayNumberValidator< T >(
       rcp(new EnhancedNumberValidator<T>(as<T>(0), arrayValidatorLen))));
   myList.set(arrayParameterName,
     Array< T >(4, 10), "array parameter", arrayValidator);
 
   RCP<ParameterList> readInPL = writeThenReadPL(myList);
 
   RCP<const EnhancedNumberValidator< T > > readInPrototypeValidator =
     rcp_dynamic_cast<const ArrayValidator<EnhancedNumberValidator<T>, T > >(
       readInPL->getEntry(
         arrayParameterName).validator(), true)->getPrototype();
   RCP<const EnhancedNumberValidator< T > > actualPrototypeValidator =
     arrayValidator->getPrototype();
 
   TEST_EQUALITY(
     readInPrototypeValidator->getMin(),
     actualPrototypeValidator->getMin()
   );
   TEST_EQUALITY(
     readInPrototypeValidator->getMax(),
     actualPrototypeValidator->getMax()
   );
   TEST_EQUALITY(
     readInPrototypeValidator->getStep(),
     actualPrototypeValidator->getStep()
   );
   TEST_EQUALITY(
     readInPrototypeValidator->getPrecision(),
     actualPrototypeValidator->getPrecision()
   );
   TEST_EQUALITY(
     readInPrototypeValidator->hasMin(),
     actualPrototypeValidator->hasMin()
   );
   TEST_EQUALITY(
     readInPrototypeValidator->hasMax(),
     actualPrototypeValidator->hasMax()
   );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [8/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	RCPNodeHandle	,
		weakPtr_basic_2	,
		T
	)

Definition at line 402 of file RCPNodeHandle_UnitTests.cpp.

 {
 
   ECHO(RCPNodeHandle nodeRef1(basicRCPNodeHandle<T>(true)));
   TEST_EQUALITY_CONST( nodeRef1.strength(), RCP_STRONG );
 
   ECHO(RCPNodeHandle nodeRef2 = nodeRef1.create_weak());
   TEST_EQUALITY_CONST( nodeRef2.strength(), RCP_WEAK );
   TEST_EQUALITY_CONST( nodeRef1.strong_count(), 1 );
   TEST_EQUALITY_CONST( nodeRef1.weak_count(), 1 );
   TEST_EQUALITY_CONST( nodeRef2.strong_count(), 1 );
   TEST_EQUALITY_CONST( nodeRef2.weak_count(), 1 );
 
   MockRCP<T> mockRCP;
 
   ECHO(nodeRef2.debug_assert_valid_ptr(mockRCP)); // Should not throw!
 
   ECHO(nodeRef2 = null); // The underlying object stays alive!
 
   TEST_EQUALITY_CONST( nodeRef2.node_ptr()==0, true );
   TEST_EQUALITY_CONST( nodeRef2.is_node_null(), true );
   TEST_EQUALITY_CONST( nodeRef2.is_valid_ptr(), true );
 
   TEST_EQUALITY_CONST( nodeRef1.node_ptr()!=0, true );
   TEST_EQUALITY_CONST( nodeRef1.is_node_null(), false );
   TEST_EQUALITY_CONST( nodeRef1.is_valid_ptr(), true );
 
   nodeRef1.debug_assert_valid_ptr(mockRCP); // Should not throw!
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [9/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	Teuchos_Validator	,
		TwoDArrayNumberValidatorConverterTest	,
		T
	)

Definition at line 433 of file Validator_SerializationTest.cpp.

 {
   std::string arrayParameterName = "array";
   ParameterList myList;
 
   const T arrayValidatorLen = as<T>(11);
   RCP<TwoDArrayNumberValidator< T > > arrayValidator =
     rcp(new TwoDArrayNumberValidator< T >(
       rcp(new EnhancedNumberValidator<T>(as<T>(0), arrayValidatorLen))));
   myList.set(arrayParameterName,
     TwoDArray< T >(4,4, 10), "array parameter", arrayValidator);
 
   RCP<ParameterList> readInPL = writeThenReadPL(myList);
 
   RCP<const EnhancedNumberValidator< T > > readInPrototypeValidator =
     rcp_dynamic_cast<const TwoDArrayValidator<EnhancedNumberValidator<T>, T > >(
       readInPL->getEntry(
         arrayParameterName).validator(), true)->getPrototype();
   RCP<const EnhancedNumberValidator< T > > actualPrototypeValidator =
     arrayValidator->getPrototype();
 
   TEST_EQUALITY(
     readInPrototypeValidator->getMin(),
     actualPrototypeValidator->getMin()
   );
   TEST_EQUALITY(
     readInPrototypeValidator->getMax(),
     actualPrototypeValidator->getMax()
   );
   TEST_EQUALITY(
     readInPrototypeValidator->getStep(),
     actualPrototypeValidator->getStep()
   );
   TEST_EQUALITY(
     readInPrototypeValidator->getPrecision(),
     actualPrototypeValidator->getPrecision()
   );
   TEST_EQUALITY(
     readInPrototypeValidator->hasMin(),
     actualPrototypeValidator->hasMin()
   );
   TEST_EQUALITY(
     readInPrototypeValidator->hasMax(),
     actualPrototypeValidator->hasMax()
   );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [10/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	RCPNodeHandle	,
		debugWithNodeTracingPrint	,
		T
	)

Definition at line 448 of file RCPNodeHandle_UnitTests.cpp.

 {
 
   TEST_EQUALITY_CONST(RCPNodeTracer::isTracingActiveRCPNodes(), false);
   RCPNodeTracer::setTracingActiveRCPNodes(true);
   TEST_EQUALITY_CONST(RCPNodeTracer::isTracingActiveRCPNodes(), true);
 
   {
 
     T *p = new T; // Never do this in production code!
     const std::string T_name = "T_name";
     const std::string concreateT_name = "concreateT_name";
     const bool has_ownership = true;
     RCPNode *node = new RCPNodeTmpl<T,DeallocDelete<T> >(
       p, DeallocDelete<T>(), has_ownership);
 
     RCPNodeHandle nodeRef(node, p, T_name, concreateT_name, has_ownership);
 
     TEST_EQUALITY_CONST(RCPNodeTracer::numActiveRCPNodes(), 1);
 
     out << "\nMake sure output is printed when there is an active node with tracing ...\n";
 
     const void* rcpNodeKey = RCPNodeTracer::getRCPNodeBaseObjMapKeyVoidPtr(p);
 
     std::ostringstream expendedOutput_oss;
     expendedOutput_oss
         << RCPNodeTracer::getActiveRCPNodeHeaderString()
         << "\n"
         << "  0: RCPNode (map_key_void_ptr=" << rcpNodeKey << ")\n"
         << "       Information = {T="<<T_name<<", ConcreteT="<<concreateT_name<<", p="<<p<<", has_ownership="<<has_ownership<<"}\n"
         << "       RCPNode address = " << node << "\n"
         << "       insertionNumber = " << node->insertion_number()
         << "\n\n"
         << RCPNodeTracer::getCommonDebugNotesString();
 
     std::ostringstream printActiveRCPNodes_out;
     RCPNodeTracer::printActiveRCPNodes(printActiveRCPNodes_out);
     TEST_EQUALITY( printActiveRCPNodes_out.str(), expendedOutput_oss.str() );
 
     // NOTE: The above test basically copied and pasted the ouptut stream code
     // from printActiveRCPNodes(...) and will need to be maintained
     // with this code.  However, this is a good test because it ensures that
     // the arguments node, p, T_name, and concreateT_name are passed, stored,
     // and retrieved correctly.  It is also a good test because it ensures
     // that output is printed when node tracing is turned on.
     //
     // This is the very definition of a "white box" test but that is just fine
     // for a unit test.
 
   }
 
   TEST_EQUALITY_CONST(RCPNodeTracer::numActiveRCPNodes(), 0);
 
   out << "\nMake sure no output is printed when there are no active nodes ...\n";
   const std::string expendedOutput = "";
   std::ostringstream printActiveRCPNodes_out;
   RCPNodeTracer::printActiveRCPNodes(printActiveRCPNodes_out);
   TEST_EQUALITY( printActiveRCPNodes_out.str(), expendedOutput );
 
   RCPNodeTracer::setTracingActiveRCPNodes(false);
   TEST_EQUALITY_CONST(RCPNodeTracer::isTracingActiveRCPNodes(), false);
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [11/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	Teuchos_Validator	,
		StringToIntegralConverterTest	,
		T
	)

Definition at line 481 of file Validator_SerializationTest.cpp.

 {
   std::string defaultStringToIntegralParameterName = "defaultsti";
   std::string stringToIntegralParameterName = "sti";
   ParameterList myList;
   RCP<StringToIntegralParameterEntryValidator< T > > defaultStiValidator = rcp(
     new StringToIntegralParameterEntryValidator< T >(
       tuple<std::string>("value1", "value2", "value3"), stringToIntegralParameterName));
   RCP<StringToIntegralParameterEntryValidator< T > > stiValidator = rcp(
     new StringToIntegralParameterEntryValidator< T >(
       tuple<std::string>("value3", "value4", "value5"),
       tuple<std::string>("the third value", "the fourth value", "the fifth value"),
       tuple< T >(3,4,5),
       stringToIntegralParameterName));
   myList.set(defaultStringToIntegralParameterName,
     "value1", "parameter with default sti validator", defaultStiValidator);
   myList.set(stringToIntegralParameterName, "value3", "parameter with sti validator",
     stiValidator);
 
   RCP<ParameterList> readInPL = writeThenReadPL(myList);
 
 
   RCP<const StringToIntegralParameterEntryValidator< T > >
   readInDefaultStiValidator =
     rcp_dynamic_cast<const StringToIntegralParameterEntryValidator< T > >(
       readInPL->getEntry(
         defaultStringToIntegralParameterName).validator(), true);
   RCP<const StringToIntegralParameterEntryValidator< T > >
   readInStiValidator =
     rcp_dynamic_cast<const StringToIntegralParameterEntryValidator< T > >(
       readInPL->getEntry(
         stringToIntegralParameterName).validator(), true);
 
   Array<std::string> readInDefaultValidStrings =
     *(readInDefaultStiValidator->validStringValues());
   Array<std::string> defaultValidStrings =
     *(defaultStiValidator->validStringValues());
   TEST_COMPARE_ARRAYS(readInDefaultValidStrings, defaultValidStrings);
 
   TEST_ASSERT(readInDefaultStiValidator->getStringDocs().is_null());
   TEST_EQUALITY( readInDefaultStiValidator->getDefaultParameterName(),
     defaultStiValidator->getDefaultParameterName());
   for(int i=0; i<defaultValidStrings.size(); ++i){
     TEST_EQUALITY(defaultStiValidator->getIntegralValue(defaultValidStrings[i]),
       readInDefaultStiValidator->getIntegralValue(defaultValidStrings[i]));
   }
 
   Array<std::string> readInValidStrings = *(readInStiValidator->validStringValues());
   Array<std::string> validStrings = *(stiValidator->validStringValues());
   TEST_COMPARE_ARRAYS(readInValidStrings, validStrings);
 
   TEST_COMPARE_ARRAYS(*(readInStiValidator->getStringDocs()),
     *(stiValidator->getStringDocs()));
   TEST_EQUALITY( readInStiValidator->getDefaultParameterName(),
     stiValidator->getDefaultParameterName());
   for(int i=0; i<validStrings.size(); ++i){
     TEST_EQUALITY(stiValidator->getIntegralValue(validStrings[i]),
       readInStiValidator->getIntegralValue(validStrings[i]));
   }
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [12/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	RCPNodeHandle	,
		debugWithoutNodeTracingPrint	,
		T
	)

Definition at line 513 of file RCPNodeHandle_UnitTests.cpp.

 {
 
   TEST_EQUALITY_CONST(RCPNodeTracer::isTracingActiveRCPNodes(), false);
   RCPNodeTracer::setTracingActiveRCPNodes(false);
   TEST_EQUALITY_CONST(RCPNodeTracer::isTracingActiveRCPNodes(), false);
 
   T *p = new T; // Never do this in production code!
   const std::string T_name = "T_name";
   const std::string concreateT_name = "concreateT_name";
   const bool has_ownership = true;
   RCPNode *node = new RCPNodeTmpl<T,DeallocDelete<T> >(
     p, DeallocDelete<T>(), has_ownership);
 
   RCPNodeHandle nodeRef(node, p, T_name, concreateT_name, has_ownership);
 
   TEST_EQUALITY_CONST(RCPNodeTracer::numActiveRCPNodes(), 0);
 
   out << "\nMake sure no output is printed when there are no active nodes without tracing ...\n";
   const std::string expendedOutput = "";
   std::ostringstream printActiveRCPNodes_out;
   RCPNodeTracer::printActiveRCPNodes(printActiveRCPNodes_out);
   TEST_EQUALITY( printActiveRCPNodes_out.str(), expendedOutput );
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [13/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	RCPNodeHandle	,
		copyConstruct	,
		T
	)

Definition at line 543 of file RCPNodeHandle_UnitTests.cpp.

 {
   RCPNodeHandle nodeRef1(basicRCPNodeHandle<T>(true));
   RCPNodeHandle nodeRef2(nodeRef1);
   TEST_EQUALITY_CONST( nodeRef1.count(), 2 );
   TEST_EQUALITY_CONST( nodeRef2.count(), 2 );
   TEST_EQUALITY_CONST( nodeRef1.has_ownership(), true );
   TEST_EQUALITY_CONST( nodeRef2.has_ownership(), true );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [14/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	RCPNodeHandle	,
		assignmentOperator	,
		T
	)

Definition at line 554 of file RCPNodeHandle_UnitTests.cpp.

 {
   RCPNodeHandle nodeRef1(basicRCPNodeHandle<T>(true));
   RCPNodeHandle nodeRef2;
   nodeRef2 = nodeRef1;
   TEST_EQUALITY_CONST( nodeRef1.count(), 2 );
   TEST_EQUALITY_CONST( nodeRef2.count(), 2 );
   TEST_EQUALITY_CONST( nodeRef1.has_ownership(), true );
   TEST_EQUALITY_CONST( nodeRef2.has_ownership(), true );
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [15/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	RCPNodeHandle	,
		extraData_basic	,
		T
	)

Definition at line 566 of file RCPNodeHandle_UnitTests.cpp.

 {
 
   RCPNodeHandle nodeRef(basicRCPNodeHandle<T>(true));
 
   const int v1 = 2;
   const any a1(v1);
   nodeRef.set_extra_data(a1, "a1", PRE_DESTROY, true);
 
   any &a2 = nodeRef.get_extra_data(a1.typeName(), "a1");
   TEST_EQUALITY_CONST( a1.same(a2), true );
   TEST_EQUALITY( any_cast<int>(a2), v1 );
 
   any *a3 = nodeRef.get_optional_extra_data(a1.typeName(), "a1");
   TEST_EQUALITY_CONST( a3!=0, true );
   TEST_EQUALITY( &a2, a3 );
   TEST_EQUALITY_CONST( a3->same(a1), true );
 
   RCPNodeHandle nodeRef2 = nodeRef;
 
   const int v2 = 3;
   a2 = v2;
   TEST_EQUALITY( any_cast<int>(a1), v1 );
   TEST_EQUALITY( any_cast<int>(*a3), v2 );
 
   any &a4 = nodeRef2.get_extra_data(a1.typeName(), "a1");
   TEST_EQUALITY( &a4, &a2 );
   TEST_EQUALITY( &a4, a3 );
   TEST_EQUALITY( any_cast<int>(a4), v2 );
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [16/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	RCPNodeHandle	,
		extraData_basic_const	,
		T
	)

Definition at line 599 of file RCPNodeHandle_UnitTests.cpp.

 {
 
   RCPNodeHandle nodeRef(basicRCPNodeHandle<T>(true));
 
   const int v1 = 2;
   const any a1(v1);
   nodeRef.set_extra_data(a1, "a1", PRE_DESTROY, true);
 
   const RCPNodeHandle nodeRef2 = nodeRef;
 
   const any &a2 = nodeRef2.get_extra_data(a1.typeName(), "a1");
   TEST_EQUALITY_CONST( a1.same(a2), true );
   TEST_EQUALITY( any_cast<int>(a2), v1 );
 
   const any *a3 = nodeRef2.get_optional_extra_data(a1.typeName(), "a1");
   TEST_EQUALITY_CONST( a3!=0, true );
   TEST_EQUALITY( &a2, a3 );
   TEST_EQUALITY_CONST( a3->same(a1), true );
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [17/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	RCPNodeHandle	,
		extraData_failed	,
		T
	)

Definition at line 622 of file RCPNodeHandle_UnitTests.cpp.

 {
 
   RCPNodeHandle nodeRef(basicRCPNodeHandle<T>(true));
 
   const int v1 = 2;
   const any a1(v1);
   nodeRef.set_extra_data(a1, "a1", PRE_DESTROY, true);
 
 #ifdef TEUCHOS_DEBUG
 
   TEST_THROW({nodeRef.get_extra_data("wrong type", "a1");},
     std::invalid_argument);
 
   TEST_THROW({nodeRef.get_extra_data(a1.typeName(), "wrong name");},
     std::invalid_argument);
 
 #endif // TEUCHOS_DEBUG
 
   any *a2 = nodeRef.get_optional_extra_data("wrong type", "a1");
   TEST_EQUALITY_CONST( a2, 0 );
 
   any *a3 = nodeRef.get_optional_extra_data(a1.typeName(), "wrong name");
   TEST_EQUALITY_CONST( a3, 0 );
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [18/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	RCPNodeHandle	,
		extraData_failed_const	,
		T
	)

Definition at line 650 of file RCPNodeHandle_UnitTests.cpp.

 {
 
   RCPNodeHandle nodeRef(basicRCPNodeHandle<T>(true));
 
   const int v1 = 2;
   const any a1(v1);
   nodeRef.set_extra_data(a1, "a1", PRE_DESTROY, true);
 
   const RCPNodeHandle nodeRef2 = nodeRef;
 
 #ifdef TEUCHOS_DEBUG
 
   TEST_THROW({nodeRef2.get_extra_data("wrong type", "a1");},
     std::invalid_argument);
 
   TEST_THROW({nodeRef2.get_extra_data(a1.typeName(), "wrong name");},
     std::invalid_argument);
 
 #endif // TEUCHOS_DEBUG
 
   const any *a2 = nodeRef2.get_optional_extra_data("wrong type", "a1");
   TEST_EQUALITY_CONST( a2, 0 );
 
   const any *a3 = nodeRef2.get_optional_extra_data(a1.typeName(), "wrong name");
   TEST_EQUALITY_CONST( a3, 0 );
 
 }

Here is the call graph for this function:

◆ TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL() [19/19]

Teuchos::TEUCHOS_UNIT_TEST_TEMPLATE_1_DECL	(	Teuchos_Dependencies	,
		RangeValidatorDepSerialization	,
		T
	)

Definition at line 915 of file Dependencies_SerializationTests.cpp.

 {
   std::string dependee1 = "dependee param";
   std::string dependee2 = "dependee param2";
   std::string dependent1 = "dependent param1";
   std::string dependent2 = "dependent param2";
   ParameterList myDepList("Range Vali Dep List");
   RCP<DependencySheet> myDepSheet = rcp(new DependencySheet);
   myDepList.set(dependee1, ScalarTraits<T>::one());
   myDepList.set(dependee2, ScalarTraits<T>::one());
   myDepList.set(dependent1, 2.0);
   myDepList.set(dependent2, 3.0);
 
     RCP<EnhancedNumberValidator<double> > double1Vali =
     rcp(new EnhancedNumberValidator<double>(0,10));
 
     RCP<EnhancedNumberValidator<double> > double2Vali =
     rcp(new EnhancedNumberValidator<double>(0,30));
 
     RCP<EnhancedNumberValidator<double> > defaultValidator =
     rcp(new EnhancedNumberValidator<double>(0,50));
 
   typename RangeValidatorDependency<T>::Range range1(0,10);
   typename RangeValidatorDependency<T>::Range range2(11,50);
 
   typename RangeValidatorDependency<T>::RangeToValidatorMap rangeValiMap;
   rangeValiMap[range1] = double1Vali;
   rangeValiMap[range2] = double2Vali;
 
   RCP<RangeValidatorDependency<T> > simpleRangeValiDep = rcp(
     new RangeValidatorDependency<T> (
       myDepList.getEntryRCP(dependee1),
       myDepList.getEntryRCP(dependent1),
       rangeValiMap));
 
   Dependency::ParameterEntryList dependentList;
   dependentList.insert(myDepList.getEntryRCP(dependent1));
   dependentList.insert(myDepList.getEntryRCP(dependent2));
 
   RCP<RangeValidatorDependency<T> > complexRangeValiDep = rcp(
     new RangeValidatorDependency<T> (
       myDepList.getEntryRCP(dependee2),
       dependentList,
       rangeValiMap,
       defaultValidator));
 
   myDepSheet->addDependency(simpleRangeValiDep);
   myDepSheet->addDependency(complexRangeValiDep);
 
   RCP<DependencySheet> readInDepSheet = rcp(new DependencySheet);
 
   XMLParameterListWriter plWriter;
   XMLObject xmlOut = plWriter.toXML(myDepList, myDepSheet);
   out << xmlOut.toString();
 
   RCP<ParameterList> readInList =
     writeThenReadPL(myDepList, myDepSheet, readInDepSheet);
 
   RCP<ParameterEntry> readinDependee1 = readInList->getEntryRCP(dependee1);
   RCP<ParameterEntry> readinDependent1 = readInList->getEntryRCP(dependent1);
   RCP<ParameterEntry> readinDependee2 = readInList->getEntryRCP(dependee2);
   RCP<ParameterEntry> readinDependent2 = readInList->getEntryRCP(dependent2);
 
   RCP<Dependency> readinDep1 =
     *(readInDepSheet->getDependenciesForParameter(readinDependee1)->begin());
 
   RCP<Dependency> readinDep2 =
     *(readInDepSheet->getDependenciesForParameter(readinDependee2)->begin());
 
   BASIC_DEPENDENCY_TEST(readinDep1, RangeValidatorDependency<T>, 1, 1);
   VERIFY_DEPENDEE(readinDep1, readinDependee1);
   VERIFY_DEPENDENT(readinDep1, readinDependent1);
 
   BASIC_DEPENDENCY_TEST(readinDep2, RangeValidatorDependency<T>, 1, 2);
   VERIFY_DEPENDEE(readinDep2, readinDependee2);
   VERIFY_DEPENDENT(readinDep2, readinDependent1);
   VERIFY_DEPENDENT(readinDep2, readinDependent2);
 
 
   RCP<RangeValidatorDependency<T> > castedDep1 =
     rcp_dynamic_cast<RangeValidatorDependency<T> >(readinDep1, true);
   RCP<RangeValidatorDependency<T> > castedDep2 =
     rcp_dynamic_cast<RangeValidatorDependency<T> >(readinDep2, true);
 
   typename RangeValidatorDependency<T>::RangeToValidatorMap readinMap1 =
     castedDep1->getRangeToValidatorMap();
   TEST_EQUALITY(readinMap1.size(), 2);
   typename RangeValidatorDependency<T>::RangeToValidatorMap::const_iterator it =
     readinMap1.begin();
   TEST_EQUALITY(it->first.first, 0);
   TEST_EQUALITY(it->first.second, 10);
   it++;
   TEST_EQUALITY(it->first.first, 11);
   TEST_EQUALITY(it->first.second, 50);
 
 
   RCP<const ParameterEntryValidator> range1Vali =
     readinMap1.find(range1)->second;
   RCP<const ParameterEntryValidator> range2Vali =
     readinMap1.find(range2)->second;
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator<double> >(
       range1Vali, true)->getMax(),
     double1Vali->getMax());
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator<double> >(
       range2Vali, true)->getMax(),
     double2Vali->getMax());
 
   typename RangeValidatorDependency<T>::RangeToValidatorMap readinMap2 =
     castedDep2->getRangeToValidatorMap();
   it = readinMap2.begin();
   TEST_EQUALITY(it->first.first, 0);
   TEST_EQUALITY(it->first.second, 10);
   it++;
   TEST_EQUALITY(it->first.first, 11);
   TEST_EQUALITY(it->first.second, 50);
 
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator<double> >(
       readinMap2.find(range1)->second, true)->getMax(),
     double1Vali->getMax());
   TEST_EQUALITY(
     rcp_dynamic_cast<const EnhancedNumberValidator<double> >(
       readinMap2.find(range2)->second, true)->getMax(),
     double2Vali->getMax());
 
   RCP<const EnhancedNumberValidator<double> > defaultReadInVali =
     rcp_dynamic_cast<const EnhancedNumberValidator<double> >(
       castedDep2->getDefaultValidator());
   TEST_EQUALITY( defaultReadInVali->getMax(), defaultValidator->getMax());
   TEST_EQUALITY( defaultReadInVali->getMin(), defaultValidator->getMin());
 }

Here is the call graph for this function:

◆ Teuchos_Version()

std::string Teuchos::Teuchos_Version ( )

Definition at line 54 of file Teuchos_Version.hpp.

                                 {
 #ifdef TEUCHOS_STANDALONE_PACKAGE
         return ("Teuchos standalone package " TEUCHOS_VERSION_STRING);
 #else
         return ("Teuchos in Trilinos " TRILINOS_VERSION_STRING);
 #endif
     }

Here is the caller graph for this function:

◆ throwScalarTraitsNanInfError()

void Teuchos::throwScalarTraitsNanInfError ( const std::string & errMsg )

Definition at line 99 of file Teuchos_ScalarTraits.cpp.

 {
 #ifdef TEUCHOS_SCALAR_TRAITS_THROW_NAN_INF_ERR
   TEUCHOS_TEST_FOR_EXCEPTION( true, std::runtime_error, errMsg );
 #endif
 }

Here is the call graph for this function:

◆ toString() [1/4]

const char* Teuchos::toString ( const EReductionType reductType )

Definition at line 69 of file Teuchos_EReductionType.cpp.

 {
   switch (reductType) {
   case REDUCE_SUM: return "REDUCE_SUM";
   case REDUCE_MIN: return "REDUCE_MIN";
   case REDUCE_MAX: return "REDUCE_MAX";
   case REDUCE_AND: return "REDUCE_AND";
   case REDUCE_BOR: return "REDUCE_BOR";
   default:
     TEUCHOS_TEST_FOR_EXCEPTION
       (true, std::invalid_argument, "Teuchos::toString(EReductionType): "
        "Invalid EReductionType value " << reductType << ".  Valid values "
        "are REDUCE_SUM = " << REDUCE_SUM << ", REDUCE_MIN = " << REDUCE_MIN
        << ", REDUCE_MAX = " << REDUCE_MIN << ", REDUCE_AND = " << REDUCE_AND
        << ", and REDUCE_BOR = " << REDUCE_BOR
        << ".");
   }
 }

Here is the caller graph for this function:

◆ toString() [2/4]

template<typename T >

std::string Teuchos::toString ( const T & t )

inline

Utility function for returning a pretty string representation of a object of type T.

NOTE: This helper function simply returns ToStringTraits<T>::toString(t) and the right way to speicalize the behavior is to specialize ToStringTraits.

Definition at line 82 of file Teuchos_toString.hpp.

 {
   return ToStringTraits<T>::toString(t);
 }

◆ toString() [3/4]

template<class Key >

std::string Teuchos::toString ( const HashSet< Key > & h )

inline

Definition at line 112 of file Teuchos_HashSet.hpp.

112 {return h.toString();}

Here is the call graph for this function:

◆ toString() [4/4]

template<class Key , class Value >

std::string Teuchos::toString ( const Hashtable< Key, Value > & h )

inline

Definition at line 263 of file Teuchos_Hashtable.hpp.

     {
       Array<Key> keys;
       Array<Value> values;
       h.arrayify(keys, values);
 
       std::string rtn = "[";
       for (int i=0; i<keys.length(); i++)
         {
           rtn += "{" + Teuchos::toString(keys[i]) + ", " + Teuchos::toString(values[i])
             + "}";
           if (i < keys.length()-1) rtn += ", ";
         }
       rtn += "]";
 
       return rtn;
     }

Here is the call graph for this function:

◆ TWODCOL_TEST_GROUP()

Teuchos::TWODCOL_TEST_GROUP ( int )

◆ TWODROW_TEST_GROUP()

Teuchos::TWODROW_TEST_GROUP ( int )

◆ typeName()

template<typename T >

std::string Teuchos::typeName ( const T & t )

Template function for returning the concrete type name of a passed-in object.

Uses the traits class TypeNameTraits so the behavior of this function can be specialized in every possible way. The default return value is typically derived from typeid(t).name().

Definition at line 113 of file Teuchos_TypeNameTraits.hpp.

 {
   typedef typename ConstTypeTraits<T>::NonConstType ncT;
 #ifndef TEUCHOS_TYPE_NAME_TRAITS_OLD_IBM
   return TypeNameTraits<ncT>::concreteName(t);
 #else
   // You can't pass general objects to AIX by value as above.  This means that
   // you will not get the concrete name printed on AIX but that is life on
   // such compilers.
   return TypeNameTraits<ncT>::name();
 #endif
 }

Here is the caller graph for this function:

◆ updateParametersFromYamlCString()

void Teuchos::updateParametersFromYamlCString	(	const char *const	data,
		const Teuchos::Ptr< Teuchos::ParameterList > &	paramList,
		bool	overwrite
	)

Definition at line 78 of file Teuchos_YamlParser.cpp.

 {
   Teuchos::RCP<Teuchos::ParameterList> updated = YAMLParameterList::parseYamlText(data);
   if(overwrite)
   {
     paramList->setParameters(*updated);
   }
   else
   {
     paramList->setParametersNotAlreadySet(*updated);
   }
 }

Here is the call graph for this function:

◆ updateParametersFromYamlFile()

void Teuchos::updateParametersFromYamlFile	(	const std::string &	yamlFileName,
		const Teuchos::Ptr< Teuchos::ParameterList > &	paramList
	)

 {
   //load the YAML file in as a new param list
   Teuchos::RCP<Teuchos::ParameterList> updated = YAMLParameterList::parseYamlFile(yamlFileName);
   //now update the original list (overwriting values with same key)
   paramList->setParameters(*updated);
 }

Here is the call graph for this function:

◆ updateParametersFromYamlString()

void Teuchos::updateParametersFromYamlString	(	const std::string &	yamlData,
		const Teuchos::Ptr< Teuchos::ParameterList > &	paramList,
		bool	overwrite
	)

 {
   Teuchos::RCP<Teuchos::ParameterList> updated = YAMLParameterList::parseYamlText(yamlData);
   if(overwrite)
   {
     paramList->setParameters(*updated);
   }
   else
   {
     paramList->setParametersNotAlreadySet(*updated);
   }
 }

Here is the call graph for this function:

◆ updateSuccess()

void Teuchos::updateSuccess	(	const bool	result,
		bool &	success
	)

inline

Update the success bool flag.

Definition at line 551 of file Teuchos_TestingHelpers.hpp.

 {
   if (!result) success = false;
 }

◆ VERIFY_DEPENDEE() [1/3]

Teuchos::VERIFY_DEPENDEE	(	readinDep1	,
		readinDependee1
	)

Here is the caller graph for this function:

◆ VERIFY_DEPENDEE() [2/3]

Teuchos::VERIFY_DEPENDEE	(	readinDep2	,
		readinDependee2
	)

◆ VERIFY_DEPENDEE() [3/3]

Teuchos::VERIFY_DEPENDEE	(	readinDep2	,
		readinDependee3
	)

◆ VERIFY_DEPENDENT() [1/4]

Teuchos::VERIFY_DEPENDENT	(	readinDep1	,
		readinDependent1
	)

Here is the caller graph for this function:

◆ VERIFY_DEPENDENT() [2/4]

Teuchos::VERIFY_DEPENDENT	(	readinDep2	,
		readinDependent2
	)

◆ VERIFY_DEPENDENT() [3/4]

Teuchos::VERIFY_DEPENDENT	(	readinDep2	,
		readinDependent3
	)

◆ VERIFY_DEPENDENT() [4/4]

Teuchos::VERIFY_DEPENDENT	(	readinDep2	,
		readinDependent1
	)

◆ writeThenReadPL() [1/2]

Teuchos::RCP< Teuchos::ParameterList > Teuchos::writeThenReadPL ( ParameterList & myList )

Write a parameter list to xml and then read that xml back in via a string. The intent of this function is to be used for testing purposes.

Parameters

paramList [in] Contains the parameters and sublists that will be written out and then read back in.

Returns: The read in parameter list.

Definition at line 48 of file Teuchos_XMLParameterListTestHelpers.cpp.

 {
   std::ostringstream xmlOut;
   writeParameterListToXmlOStream(myList, xmlOut);
   return getParametersFromXmlString(xmlOut.str());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ writeThenReadPL() [2/2]

Teuchos::RCP< Teuchos::ParameterList > Teuchos::writeThenReadPL	(	ParameterList &	myList,
		RCP< DependencySheet >	depSheetIn,
		RCP< DependencySheet >	depSheetOut
	)

Write a parameter list to xml and then read that xml back in via a string. The intent of this function is to be used for testing purposes.

Parameters

paramList	[in] Contains the parameters and sublists that will be written out and then read back in.
depSheetIn	[in] The Dependency Sheet from which Dependencies should be should be written.
depSheetOut	[out] The Dependency Sheet into which Dependencies should be placed once read.

Returns: The read in parameter list.

Definition at line 57 of file Teuchos_XMLParameterListTestHelpers.cpp.

 {
   std::ostringstream xmlOut;
   writeParameterListToXmlOStream(myList, xmlOut, depSheetIn);
   return getParametersFromXmlString(xmlOut.str(), depSheetOut);
 }

Here is the call graph for this function:

◆ XMLObject::addAttribute< const std::string & >() [1/2]

template<>

void Teuchos::XMLObject::addAttribute< const std::string &>	(	const std::string &	name,
		const std::string &	value
	)

Definition at line 155 of file Teuchos_XMLObject.cpp.

 {
   TEUCHOS_TEST_FOR_EXCEPTION(is_null(ptr_), Teuchos::EmptyXMLError,
              "XMLObject::addAttribute: XMLObject is empty");
   ptr_->addAttribute(name, value);
 }

Here is the call graph for this function:

◆ XMLObject::addAttribute< const std::string & >() [2/2]

template<>

TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT void Teuchos::XMLObject::addAttribute< const std::string &>	(	const std::string &	name,
		const std::string &	value
	)

Definition at line 155 of file Teuchos_XMLObject.cpp.

 {
   TEUCHOS_TEST_FOR_EXCEPTION(is_null(ptr_), Teuchos::EmptyXMLError,
              "XMLObject::addAttribute: XMLObject is empty");
   ptr_->addAttribute(name, value);
 }

Here is the call graph for this function:

◆ XMLObject::getRequired< std::string >() [1/2]

template<>

std::string Teuchos::XMLObject::getRequired< std::string > ( const std::string & name ) const

Definition at line 124 of file Teuchos_XMLObject.cpp.

 {
     return getRequired(name);
 }

Here is the call graph for this function:

◆ XMLObject::getRequired< std::string >() [2/2]

template<>

TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT std::string Teuchos::XMLObject::getRequired< std::string > ( const std::string & name ) const

Definition at line 124 of file Teuchos_XMLObject.cpp.

 {
     return getRequired(name);
 }

Here is the call graph for this function:

Variable Documentation

◆ andCon

RCP<AndCondition> Teuchos::andCon = rcp(new AndCondition(conList))

Definition at line 456 of file Dependencies_SerializationTests.cpp.

◆ basicStringValiDep

RCP<StringValidatorDependency> Teuchos::basicStringValiDep

Initial value:

= rcp(
    new StringValidatorDependency(
      myDepList.getEntryRCP(dependee1),
      myDepList.getEntryRCP(dependent1),
      valuesAndValidators))

Definition at line 733 of file Dependencies_SerializationTests.cpp.

◆ binCon

RCP< BinCondition > Teuchos::binCon = rcp(new BinCondition (conList))

Definition at line 295 of file Condition_Serialization_UnitTests.cpp.

◆ binConDep

RCP<ConditionVisualDependency> Teuchos::binConDep

Initial value:

=
    rcp(new ConditionVisualDependency(
      binCon,
      testList.getEntryRCP(dependent1Name)))

Definition at line 297 of file Condition_Serialization_UnitTests.cpp.

◆ BinCondition

Teuchos::BinCondition

Initial value:

{

ConditionXMLConverterDB::printKnownConverters(out)

ngspicetoModelica.out

out

Definition: ngspicetoModelica.py:733

Definition at line 275 of file Condition_Serialization_UnitTests.cpp.

◆ boolCon

RCP<BoolCondition> Teuchos::boolCon

Initial value:

=

rcp(new BoolCondition(myDepList.getEntryRCP(dependee2)))

RCP< ParameterEntry > getEntryRCP(const std::string &name)

Retrieves the RCP for an entry with the name name if it exists.

Definition: Teuchos_ParameterList.hpp:1028

RCP< T > rcp(const boost::shared_ptr< T > &sptr)

Conversion function that takes in a boost::shared_ptr object and spits out a Teuchos::RCP object...

Teuchos::dependee2

std::string dependee2

Definition: Dependencies_SerializationTests.cpp:427

Teuchos::myDepList

ParameterList myDepList("String Vali Dep List")

Definition at line 447 of file Dependencies_SerializationTests.cpp.

◆ boolCon1

RCP< BoolCondition > Teuchos::boolCon1

Initial value:

=

rcp(new BoolCondition(testList.getEntryRCP(paramName1)))

Teuchos::testList

ParameterList testList("Condition Test List")

RCP< ParameterEntry > getEntryRCP(const std::string &name)

Retrieves the RCP for an entry with the name name if it exists.

Definition: Teuchos_ParameterList.hpp:1028

Teuchos::paramName1

std::string paramName1

Definition: Condition_Serialization_UnitTests.cpp:277

RCP< T > rcp(const boost::shared_ptr< T > &sptr)

Conversion function that takes in a boost::shared_ptr object and spits out a Teuchos::RCP object...

Definition at line 287 of file Condition_Serialization_UnitTests.cpp.

◆ boolCon2

RCP<BoolCondition> Teuchos::boolCon2

Initial value:

=

rcp(new BoolCondition(testList.getEntryRCP(paramName1)))

Teuchos::testList

ParameterList testList("Condition Test List")

RCP< ParameterEntry > getEntryRCP(const std::string &name)

Retrieves the RCP for an entry with the name name if it exists.

Definition: Teuchos_ParameterList.hpp:1028

Teuchos::paramName1

std::string paramName1

Definition: Condition_Serialization_UnitTests.cpp:277

RCP< T > rcp(const boost::shared_ptr< T > &sptr)

Conversion function that takes in a boost::shared_ptr object and spits out a Teuchos::RCP object...

Definition at line 289 of file Condition_Serialization_UnitTests.cpp.

◆ BoolLogicConditionSerialization

Teuchos::BoolLogicConditionSerialization

Definition at line 275 of file Condition_Serialization_UnitTests.cpp.

◆ boolVisConverter

BoolVisualDependencyXMLConverter Teuchos::boolVisConverter

Definition at line 1088 of file Dependencies_SerializationTests.cpp.

◆ boolVisDep

RCP<BoolVisualDependency> Teuchos::boolVisDep

Initial value:

=

rcp(new BoolVisualDependency(dependeeParam, dependentParam))

Teuchos::RCP::rcp_dynamic_cast

RCP< T > rcp(const boost::shared_ptr< T > &sptr)

Conversion function that takes in a boost::shared_ptr object and spits out a Teuchos::RCP object...

Teuchos::dependentParam

RCP< ParameterEntry > dependentParam

Definition: Dependencies_SerializationTests.cpp:1081

Teuchos::dependeeParam

RCP< ParameterEntry > dependeeParam

Definition: Dependencies_SerializationTests.cpp:1080

Definition at line 1082 of file Dependencies_SerializationTests.cpp.

◆ castedDep1

RCP< StringValidatorDependency > Teuchos::castedDep1

Initial value:

=

rcp_dynamic_cast<ConditionVisualDependency>(readinDep1, true)

Teuchos::readinDep1

RCP< Dependency > readinDep1

Definition: Dependencies_SerializationTests.cpp:492

RCP< T2 > rcp_dynamic_cast(const RCP< T1 > &p1, bool throw_on_fail=false)

Dynamic cast of underlying RCP type from T1* to T2*.

Definition at line 513 of file Dependencies_SerializationTests.cpp.

◆ castedDep2

RCP< StringValidatorDependency > Teuchos::castedDep2

Initial value:

=

rcp_dynamic_cast<ConditionVisualDependency>(readinDep2, true)

Teuchos::readinDep2

RCP< Dependency > readinDep2

Definition: Dependencies_SerializationTests.cpp:495

Teuchos::RCP::rcp_dynamic_cast

RCP< T2 > rcp_dynamic_cast(const RCP< T1 > &p1, bool throw_on_fail=false)

Dynamic cast of underlying RCP type from T1* to T2*.

Definition at line 515 of file Dependencies_SerializationTests.cpp.

◆ complexConVisDep

RCP<ConditionVisualDependency> Teuchos::complexConVisDep

Initial value:

= rcp(
    new ConditionVisualDependency(
      andCon,
      dependentList,
      false))

Definition at line 467 of file Dependencies_SerializationTests.cpp.

◆ complexStringValiDep

RCP<StringValidatorDependency> Teuchos::complexStringValiDep

Initial value:

= rcp(
    new StringValidatorDependency(
      myDepList.getEntryRCP(dependee2),
      dependentList,
      valuesAndValidators,
      defaultVali))

Definition at line 743 of file Dependencies_SerializationTests.cpp.

◆ conditionVal1

StringCondition::ValueList Teuchos::conditionVal1

Initial value:

=

tuple<std::string>("steve", "blah", "your face")

Definition at line 441 of file Dependencies_SerializationTests.cpp.

◆ ConditionVisualDepSerialization

Teuchos::ConditionVisualDepSerialization

Initial value:

{

std::string dependee1 = "string param"

Definition at line 425 of file Dependencies_SerializationTests.cpp.

◆ conList

Condition::ConstConditionList Teuchos::conList

Initial value:

=

tuple<RCP<const Condition> >(boolCon1, boolCon2)

Teuchos::boolCon1

RCP< BoolCondition > boolCon1

Definition: Condition_Serialization_UnitTests.cpp:287

Teuchos::boolCon2

RCP< BoolCondition > boolCon2

Definition: Condition_Serialization_UnitTests.cpp:289

Definition at line 292 of file Condition_Serialization_UnitTests.cpp.

◆ dbl_nan

TEUCHOSCORE_LIB_DLL_EXPORT const double Teuchos::dbl_nan = +returnDoubleZero()/returnDoubleZero()

Definition at line 123 of file Teuchos_ScalarTraits.cpp.

◆ defaultVali

RCP<EnhancedNumberValidator<double> > Teuchos::defaultVali

Initial value:

=

rcp(new EnhancedNumberValidator<double>(4,90))

RCP< T > rcp(const boost::shared_ptr< T > &sptr)

Conversion function that takes in a boost::shared_ptr object and spits out a Teuchos::RCP object...

Definition at line 726 of file Dependencies_SerializationTests.cpp.

◆ dependee2

std::string Teuchos::dependee2 = "bool param"

Definition at line 427 of file Dependencies_SerializationTests.cpp.

◆ dependee3

std::string Teuchos::dependee3 = "int param"

Definition at line 428 of file Dependencies_SerializationTests.cpp.

◆ dependeeParam

RCP<ParameterEntry> Teuchos::dependeeParam = rcp(new ParameterEntry(true))

Definition at line 1080 of file Dependencies_SerializationTests.cpp.

◆ DependencySerializationExceptions

Teuchos::DependencySerializationExceptions

Initial value:

{
  RCP<DependencySheet> depSheet = rcp(new DependencySheet)

Definition at line 1063 of file Dependencies_SerializationTests.cpp.

◆ dependent1

std::string Teuchos::dependent1 = "dependent param1"

Definition at line 429 of file Dependencies_SerializationTests.cpp.

◆ dependent1Name

std::string Teuchos::dependent1Name = "dependent1"

Definition at line 279 of file Condition_Serialization_UnitTests.cpp.

◆ dependent2

std::string Teuchos::dependent2 = "dependent param2"

Definition at line 430 of file Dependencies_SerializationTests.cpp.

◆ dependent3

std::string Teuchos::dependent3 = "dependent param3"

Definition at line 431 of file Dependencies_SerializationTests.cpp.

◆ dependentList

Dependency::ParameterEntryList Teuchos::dependentList

Definition at line 463 of file Dependencies_SerializationTests.cpp.

◆ dependentParam

RCP<ParameterEntry> Teuchos::dependentParam = rcp(new ParameterEntry("blah"))

Definition at line 1081 of file Dependencies_SerializationTests.cpp.

◆ dependentValue

std::string Teuchos::dependentValue = "hi there!"

Definition at line 282 of file Condition_Serialization_UnitTests.cpp.

◆ depSheet1

RCP< DependencySheet > Teuchos::depSheet1 = rcp(new DependencySheet)

Definition at line 302 of file Condition_Serialization_UnitTests.cpp.

◆ depSheetIn

RCP< DependencySheet > Teuchos::depSheetIn = rcp(new DependencySheet)

Definition at line 305 of file Condition_Serialization_UnitTests.cpp.

◆ double1Vali

RCP<EnhancedNumberValidator<double> > Teuchos::double1Vali

Initial value:

=

rcp(new EnhancedNumberValidator<double>(0,10))

RCP< T > rcp(const boost::shared_ptr< T > &sptr)

Conversion function that takes in a boost::shared_ptr object and spits out a Teuchos::RCP object...

Definition at line 720 of file Dependencies_SerializationTests.cpp.

◆ double2Vali

RCP<EnhancedNumberValidator<double> > Teuchos::double2Vali

Initial value:

=

rcp(new EnhancedNumberValidator<double>(0,30))

RCP< T > rcp(const boost::shared_ptr< T > &sptr)

Conversion function that takes in a boost::shared_ptr object and spits out a Teuchos::RCP object...

Definition at line 723 of file Dependencies_SerializationTests.cpp.

◆ EDiagChar

const char Teuchos::EDiagChar = {'U' , 'N' }

Definition at line 69 of file Teuchos_BLAS.cpp.

◆ entryIDsMap

Teuchos::entryIDsMap[dependeeParam] = 1

Definition at line 1085 of file Dependencies_SerializationTests.cpp.

◆ ESideChar

const char Teuchos::ESideChar = {'L' , 'R' }

Definition at line 66 of file Teuchos_BLAS.cpp.

◆ ETranspChar

const char Teuchos::ETranspChar = {'N' , 'T' , 'C' }

Definition at line 67 of file Teuchos_BLAS.cpp.

◆ ETypeChar

const char Teuchos::ETypeChar = {'G' , 'L', 'U', 'H', 'B', 'Q', 'Z' }

Definition at line 70 of file Teuchos_BLAS.cpp.

◆ EUploChar

const char Teuchos::EUploChar = {'U' , 'L' }

Definition at line 68 of file Teuchos_BLAS.cpp.

◆ flt_nan

TEUCHOSCORE_LIB_DLL_EXPORT const float Teuchos::flt_nan = +returnFloatZero()/returnFloatZero()

Definition at line 122 of file Teuchos_ScalarTraits.cpp.

◆ g_arraySize

const int Teuchos::g_arraySize = 5

Definition at line 63 of file ParameterList_SerializationTest.cpp.

◆ gmp_rng

gmp_randclass Teuchos::gmp_rng

◆ long

std::complex< double > std::complex< double > double Teuchos::long

Definition at line 78 of file Teuchos_PromotionTraits.hpp.

◆ myDepList

ParameterList Teuchos::myDepList("String Vali Dep List") ( "Condition Visual Dep List" )

◆ myDepSheet

RCP< DependencySheet > Teuchos::myDepSheet = rcp(new DependencySheet)

Definition at line 433 of file Dependencies_SerializationTests.cpp.

◆ notCon

RCP<NotCondition> Teuchos::notCon = rcp(new NotCondition(boolCon1))

Definition at line 351 of file Condition_Serialization_UnitTests.cpp.

◆ notConDep

RCP<ConditionVisualDependency> Teuchos::notConDep

Initial value:

=
    rcp(new ConditionVisualDependency(
      notCon,
      testList.getEntryRCP(dependent1Name)))

Definition at line 353 of file Condition_Serialization_UnitTests.cpp.

◆ NotConditionSerialization

Teuchos::NotConditionSerialization

Initial value:

{

ConditionXMLConverterDB::printKnownConverters(out)

ngspicetoModelica.out

out

Definition: ngspicetoModelica.py:733

Definition at line 338 of file Condition_Serialization_UnitTests.cpp.

◆ numberCon

RCP<NumberCondition<int> > Teuchos::numberCon

Initial value:

=

rcp(new NumberCondition<int>(myDepList.getEntryRCP(dependee3)))

RCP< ParameterEntry > getEntryRCP(const std::string &name)

Retrieves the RCP for an entry with the name name if it exists.

Definition: Teuchos_ParameterList.hpp:1028

Teuchos::RCP::rcp_dynamic_cast

RCP< T > rcp(const boost::shared_ptr< T > &sptr)

Conversion function that takes in a boost::shared_ptr object and spits out a Teuchos::RCP object...

Teuchos::dependee3

std::string dependee3

Definition: Dependencies_SerializationTests.cpp:428

Teuchos::myDepList

ParameterList myDepList("String Vali Dep List")

Definition at line 450 of file Dependencies_SerializationTests.cpp.

◆ ObjectType_name

const std::string Teuchos::ObjectType_name = "Foo Type"

Definition at line 50 of file ObjectBuilder_UnitTests.cpp.

◆ paramName1

std::string Teuchos::paramName1 = "bool param1"

Definition at line 277 of file Condition_Serialization_UnitTests.cpp.

◆ paramName2

std::string Teuchos::paramName2 = "bool param2"

Definition at line 278 of file Condition_Serialization_UnitTests.cpp.

◆ paramValue1

bool Teuchos::paramValue1 = true

Definition at line 280 of file Condition_Serialization_UnitTests.cpp.

◆ paramValue2

bool Teuchos::paramValue2 = false

Definition at line 281 of file Condition_Serialization_UnitTests.cpp.

◆ plWriter

XMLParameterListWriter Teuchos::plWriter

Definition at line 478 of file Dependencies_SerializationTests.cpp.

◆ readInCon

RCP< const NotCondition > Teuchos::readInCon

Initial value:

=

rcp_dynamic_cast<const BinCondition >(readInDep1->getCondition(), true)

Teuchos::BinCondition

BinCondition

Definition: Condition_Serialization_UnitTests.cpp:275

Teuchos::readInDep1

RCP< ConditionVisualDependency > readInDep1

Definition: Condition_Serialization_UnitTests.cpp:312

RCP< T2 > rcp_dynamic_cast(const RCP< T1 > &p1, bool throw_on_fail=false)

Dynamic cast of underlying RCP type from T1* to T2*.

Definition at line 322 of file Condition_Serialization_UnitTests.cpp.

◆ readInConList

Condition::ConstConditionList Teuchos::readInConList = readInCon->getConditions()

Definition at line 326 of file Condition_Serialization_UnitTests.cpp.

◆ readInDep1

RCP< ConditionVisualDependency > Teuchos::readInDep1

Initial value:

=
    rcp_dynamic_cast<ConditionVisualDependency>(
      *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()))

Definition at line 312 of file Condition_Serialization_UnitTests.cpp.

◆ readinDep1

RCP< Dependency > Teuchos::readinDep1

Initial value:

=

*(readInDepSheet->getDependenciesForParameter(readinDependee1)->begin())

Teuchos::readinDependee1

RCP< ParameterEntry > readinDependee1

Definition: Dependencies_SerializationTests.cpp:485

RCP< DependencySheet > readInDepSheet

Definition: Dependencies_SerializationTests.cpp:476

Definition at line 492 of file Dependencies_SerializationTests.cpp.

◆ readInDep2

RCP<ConditionVisualDependency> Teuchos::readInDep2

Initial value:

=
    rcp_dynamic_cast<ConditionVisualDependency>(
      *(depSheetIn->getDependenciesForParameter(readInDependee1)->begin()))

Definition at line 315 of file Condition_Serialization_UnitTests.cpp.

◆ readinDep2

RCP< Dependency > Teuchos::readinDep2

Initial value:

=

*(readInDepSheet->getDependenciesForParameter(readinDependee2)->begin())

RCP< DependencySheet > readInDepSheet

Definition: Dependencies_SerializationTests.cpp:476

Teuchos::readinDependee2

RCP< ParameterEntry > readinDependee2

Definition: Dependencies_SerializationTests.cpp:487

Definition at line 495 of file Dependencies_SerializationTests.cpp.

◆ readinDep3

RCP<Dependency> Teuchos::readinDep3

Initial value:

=

*(readInDepSheet->getDependenciesForParameter(readinDependee3)->begin())

Teuchos::readinDependee3

RCP< ParameterEntry > readinDependee3

Definition: Dependencies_SerializationTests.cpp:489

RCP< DependencySheet > readInDepSheet

Definition: Dependencies_SerializationTests.cpp:476

Definition at line 498 of file Dependencies_SerializationTests.cpp.

◆ readInDependee1

RCP< ParameterEntry > Teuchos::readInDependee1 = readinList->getEntryRCP(paramName1)

Definition at line 309 of file Condition_Serialization_UnitTests.cpp.

◆ readinDependee1

RCP< ParameterEntry > Teuchos::readinDependee1 = readInList->getEntryRCP(dependee1)

Definition at line 485 of file Dependencies_SerializationTests.cpp.

◆ readInDependee2

RCP<ParameterEntry> Teuchos::readInDependee2 = readinList->getEntryRCP(paramName2)

Definition at line 310 of file Condition_Serialization_UnitTests.cpp.

◆ readinDependee2

RCP< ParameterEntry > Teuchos::readinDependee2 = readInList->getEntryRCP(dependee2)

Definition at line 487 of file Dependencies_SerializationTests.cpp.

◆ readinDependee3

RCP<ParameterEntry> Teuchos::readinDependee3 = readInList->getEntryRCP(dependee3)

Definition at line 489 of file Dependencies_SerializationTests.cpp.

◆ readinDependent1

RCP< ParameterEntry > Teuchos::readinDependent1 = readInList->getEntryRCP(dependent1)

Definition at line 486 of file Dependencies_SerializationTests.cpp.

◆ readinDependent2

RCP< ParameterEntry > Teuchos::readinDependent2 = readInList->getEntryRCP(dependent2)

Definition at line 488 of file Dependencies_SerializationTests.cpp.

◆ readinDependent3

RCP<ParameterEntry> Teuchos::readinDependent3 = readInList->getEntryRCP(dependent3)

Definition at line 490 of file Dependencies_SerializationTests.cpp.

◆ readInDepSheet

RCP< DependencySheet > Teuchos::readInDepSheet = rcp(new DependencySheet)

Definition at line 476 of file Dependencies_SerializationTests.cpp.

◆ readinList

RCP< ParameterList > Teuchos::readinList

Initial value:

=

writeThenReadPL(testList, depSheet1, depSheetIn)

Teuchos::depSheet1

RCP< DependencySheet > depSheet1

Definition: Condition_Serialization_UnitTests.cpp:302

Teuchos::depSheetIn

RCP< DependencySheet > depSheetIn

Definition: Condition_Serialization_UnitTests.cpp:305

Teuchos::testList

ParameterList testList("Condition Test List")

Teuchos::writeThenReadPL

TEUCHOSPARAMETERLIST_LIB_DLL_EXPORT RCP< ParameterList > writeThenReadPL(ParameterList &myList)

Write a parameter list to xml and then read that xml back in via a string. The intent of this functio...

Definition: Teuchos_XMLParameterListTestHelpers.cpp:48

Definition at line 306 of file Condition_Serialization_UnitTests.cpp.

◆ readInList

out<< xmlOut.toString(); RCP<ParameterList> Teuchos::readInList

Initial value:

=

writeThenReadPL(myDepList, myDepSheet, readInDepSheet)

Teuchos::myDepSheet

RCP< DependencySheet > myDepSheet

Definition: Dependencies_SerializationTests.cpp:433